From 95b1e9e183efbdf8bc16563bde5d85b31248fc63 Mon Sep 17 00:00:00 2001 From: "Adam Schepis (he/him)" Date: Tue, 28 May 2024 13:10:56 -0400 Subject: [PATCH] Add and publish Python SDK (#14) --- .github/workflows/ci.yml | 12 +- CHANGELOG.md | 2 + Makefile | 9 +- pyproject.toml | 22 + sdk/python/Pulumi.yaml | 0 sdk/python/README.md | 9 + .../chronosphereio_chronosphere/README.md | 4 + .../chronosphereio_chronosphere/__init__.py | 280 ++ .../chronosphereio_chronosphere/_inputs.py | 3078 +++++++++++++++++ .../chronosphereio_chronosphere/_utilities.py | 250 ++ .../blackhole_alert_notifier.py | 165 + .../chronosphereio_chronosphere/bucket.py | 355 ++ .../bucket_data_source.py | 113 + .../classic_dashboard.py | 199 ++ .../chronosphereio_chronosphere/collection.py | 267 ++ .../config/__init__.py | 8 + .../config/__init__.pyi | 19 + .../config/vars.py | 33 + .../chronosphereio_chronosphere/dashboard.py | 199 ++ .../derived_label.py | 305 ++ .../derived_metric.py | 271 ++ .../chronosphereio_chronosphere/drop_rule.py | 372 ++ .../email_alert_notifier.py | 302 ++ .../gcp_metrics_integration.py | 200 ++ .../grafana_dashboard.py | 199 ++ .../mapping_rule.py | 440 +++ .../chronosphereio_chronosphere/monitor.py | 509 +++ .../notification_policy.py | 371 ++ .../notification_policy_data_source.py | 170 + .../opsgenie_alert_notifier.py | 714 ++++ .../chronosphereio_chronosphere/outputs.py | 3010 ++++++++++++++++ .../pagerduty_alert_notifier.py | 817 +++++ .../chronosphereio_chronosphere/provider.py | 163 + .../pulumi-plugin.json | 4 + .../chronosphereio_chronosphere/py.typed | 0 .../recording_rule.py | 370 ++ .../resource_pools_config.py | 216 ++ .../rollup_rule.py | 612 ++++ .../service_account.py | 277 ++ .../service_data_source.py | 97 + .../slack_alert_notifier.py | 1055 ++++++ .../chronosphereio_chronosphere/team.py | 233 ++ .../trace_jaeger_remote_sampling_strategy.py | 237 ++ .../trace_metrics_rule.py | 339 ++ .../trace_tail_sampling_rules.py | 166 + .../victorops_alert_notifier.py | 645 ++++ .../webhook_alert_notifier.py | 406 +++ sdk/python/go.mod | 3 + sdk/python/setup.py | 44 + 49 files changed, 17561 insertions(+), 10 deletions(-) create mode 100644 pyproject.toml create mode 100644 sdk/python/Pulumi.yaml create mode 100644 sdk/python/README.md create mode 100644 sdk/python/chronosphereio_chronosphere/README.md create mode 100644 sdk/python/chronosphereio_chronosphere/__init__.py create mode 100644 sdk/python/chronosphereio_chronosphere/_inputs.py create mode 100644 sdk/python/chronosphereio_chronosphere/_utilities.py create mode 100644 sdk/python/chronosphereio_chronosphere/blackhole_alert_notifier.py create mode 100644 sdk/python/chronosphereio_chronosphere/bucket.py create mode 100644 sdk/python/chronosphereio_chronosphere/bucket_data_source.py create mode 100644 sdk/python/chronosphereio_chronosphere/classic_dashboard.py create mode 100644 sdk/python/chronosphereio_chronosphere/collection.py create mode 100644 sdk/python/chronosphereio_chronosphere/config/__init__.py create mode 100644 sdk/python/chronosphereio_chronosphere/config/__init__.pyi create mode 100644 sdk/python/chronosphereio_chronosphere/config/vars.py create mode 100644 sdk/python/chronosphereio_chronosphere/dashboard.py create mode 100644 sdk/python/chronosphereio_chronosphere/derived_label.py create mode 100644 sdk/python/chronosphereio_chronosphere/derived_metric.py create mode 100644 sdk/python/chronosphereio_chronosphere/drop_rule.py create mode 100644 sdk/python/chronosphereio_chronosphere/email_alert_notifier.py create mode 100644 sdk/python/chronosphereio_chronosphere/gcp_metrics_integration.py create mode 100644 sdk/python/chronosphereio_chronosphere/grafana_dashboard.py create mode 100644 sdk/python/chronosphereio_chronosphere/mapping_rule.py create mode 100644 sdk/python/chronosphereio_chronosphere/monitor.py create mode 100644 sdk/python/chronosphereio_chronosphere/notification_policy.py create mode 100644 sdk/python/chronosphereio_chronosphere/notification_policy_data_source.py create mode 100644 sdk/python/chronosphereio_chronosphere/opsgenie_alert_notifier.py create mode 100644 sdk/python/chronosphereio_chronosphere/outputs.py create mode 100644 sdk/python/chronosphereio_chronosphere/pagerduty_alert_notifier.py create mode 100644 sdk/python/chronosphereio_chronosphere/provider.py create mode 100644 sdk/python/chronosphereio_chronosphere/pulumi-plugin.json create mode 100644 sdk/python/chronosphereio_chronosphere/py.typed create mode 100644 sdk/python/chronosphereio_chronosphere/recording_rule.py create mode 100644 sdk/python/chronosphereio_chronosphere/resource_pools_config.py create mode 100644 sdk/python/chronosphereio_chronosphere/rollup_rule.py create mode 100644 sdk/python/chronosphereio_chronosphere/service_account.py create mode 100644 sdk/python/chronosphereio_chronosphere/service_data_source.py create mode 100644 sdk/python/chronosphereio_chronosphere/slack_alert_notifier.py create mode 100644 sdk/python/chronosphereio_chronosphere/team.py create mode 100644 sdk/python/chronosphereio_chronosphere/trace_jaeger_remote_sampling_strategy.py create mode 100644 sdk/python/chronosphereio_chronosphere/trace_metrics_rule.py create mode 100644 sdk/python/chronosphereio_chronosphere/trace_tail_sampling_rules.py create mode 100644 sdk/python/chronosphereio_chronosphere/victorops_alert_notifier.py create mode 100644 sdk/python/chronosphereio_chronosphere/webhook_alert_notifier.py create mode 100644 sdk/python/go.mod create mode 100644 sdk/python/setup.py diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index c731d0db..6204acb2 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -108,11 +108,11 @@ jobs: uses: actions/setup-dotnet@v4 with: dotnet-version: ${{ env.DOTNETVERSION }} - # - if: matrix.language == 'python' - # name: Setup Python - # uses: actions/setup-python@v5 - # with: - # python-version: ${{ env.PYTHONVERSION }} + - if: matrix.language == 'python' + name: Setup Python + uses: actions/setup-python@v5 + with: + python-version: ${{ env.PYTHONVERSION }} - if: matrix.language == 'java' name: Setup Java uses: actions/setup-java@v4 @@ -136,8 +136,8 @@ jobs: - nodejs - dotnet - java + - python # - go - # - python # - name: Download provider + tfgen binaries # uses: actions/download-artifact@v4 diff --git a/CHANGELOG.md b/CHANGELOG.md index 4a837790..848b5f46 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -2,3 +2,5 @@ ## Unreleased +- Create and publish Python SDK + diff --git a/Makefile b/Makefile index 9f0ee79e..c4cf4d3e 100644 --- a/Makefile +++ b/Makefile @@ -17,9 +17,9 @@ development: install_plugins provider build_sdks install_sdks build: install_plugins provider build_sdks install_sdks -# TODO: get python and go SDKs building +# TODO: get go SDK building # build_sdks: build_nodejs build_python build_go build_dotnet build_java -build_sdks: build_nodejs build_dotnet build_java +build_sdks: build_nodejs build_python build_dotnet build_java install_go_sdk: @@ -64,7 +64,7 @@ build_nodejs: build_python: PYPI_VERSION := $(shell pulumictl get version --language python) build_python: export PULUMI_HOME := $(WORKING_DIR)/.pulumi build_python: export PATH := $(WORKING_DIR)/.pulumi/bin:$(PATH) -#build_python: export PULUMI_CONVERT_EXAMPLES_CACHE_DIR := $(WORKING_DIR)/.pulumi/examples-cache +build_python: export PULUMI_CONVERT_EXAMPLES_CACHE_DIR := $(WORKING_DIR)/.pulumi/examples-cache build_python: rm -rf sdk/python/ PULUMI_CONVERT=$(PULUMI_CONVERT) PULUMI_DISABLE_AUTOMATIC_PLUGIN_ACQUISITION=$(PULUMI_CONVERT) $(WORKING_DIR)/bin/$(TFGEN) python --out sdk/python/ @@ -72,6 +72,7 @@ build_python: printf "module fake_python_module // Exclude this directory from Go tools\n\ngo 1.21\n" > go.mod && \ cp ../../README.md . && \ rm -rf ./bin/ ../python.bin/ && cp -R . ../python.bin && mv ../python.bin ./bin && \ + cp ../../pyproject.toml ./bin/ && \ sed -i.bak -e 's/^ version = .*/ version = "$(PYPI_VERSION)"/g' ./bin/pyproject.toml && \ rm ./bin/pyproject.toml.bak && rm ./bin/go.mod && \ python3 -m venv venv && \ @@ -142,4 +143,4 @@ bin/pulumi-java-gen: @cd provider && go list -f "{{slice .Version 1}}" -m github.com/pulumi/pulumi/pkg/v3 | tee ../$@ # .PHONY: development build build_sdks install_go_sdk install_java_sdk install_python_sdk install_sdks only_build build_dotnet build_go build_java build_nodejs build_python clean cleanup help install_dotnet_sdk install_nodejs_sdk install_plugins lint_provider provider test tfgen test_provider -.PHONY: development build build_sdks install_go_sdk install_java_sdk install_python_sdk install_sdks only_build build_go build_nodejs clean cleanup help install_dotnet_sdk install_nodejs_sdk install_plugins lint_provider provider test tfgen test_provider +.PHONY: development build build_sdks install_go_sdk install_java_sdk install_python_sdk install_sdks only_build build_dotnet build_java build_nodejs build_python clean cleanup help install_dotnet_sdk install_nodejs_sdk install_plugins lint_provider provider test tfgen test_provider diff --git a/pyproject.toml b/pyproject.toml new file mode 100644 index 00000000..579dee31 --- /dev/null +++ b/pyproject.toml @@ -0,0 +1,22 @@ +[project] + name = "pulumi_chronosphere" + description = "A Pulumi package for creating and managing Chronosphere resources." + dependencies = ["parver>=0.2.1", "pulumi>=3.0.0,<4.0.0", "semver>=2.8.1"] + keywords = ["pulumi", "chronosphere"] + readme = "README.md" + requires-python = ">=3.8" + version = "0.0.0" + [project.license] + text = "Apache-2.0" + [project.urls] + Homepage = "https://chronosphere.io" + Repository = "https://github.com/chronosphereio/pulumi-chronosphere" + +[build-system] + requires = ["setuptools>=61.0"] + build-backend = "setuptools.build_meta" + +[tool] + [tool.setuptools] + [tool.setuptools.package-data] + pulumi_chronosphere = ["py.typed", "pulumi-plugin.json"] diff --git a/sdk/python/Pulumi.yaml b/sdk/python/Pulumi.yaml new file mode 100644 index 00000000..e69de29b diff --git a/sdk/python/README.md b/sdk/python/README.md new file mode 100644 index 00000000..07a8d1be --- /dev/null +++ b/sdk/python/README.md @@ -0,0 +1,9 @@ +# A Pulumi Resource Provider for Chronosphere + +The Chronosphere Pulumi Provider allows [Pulumi](https://www.pulumi.com/) to manage supported [Chronosphere resources](https://docs.chronosphere.io/administer). + +- [Documentation](https://docs.chronosphere.io/administer) + +## Contact support + +[Contact Chronosphere support](https://docs.chronosphere.io/support/contact-support) to ask questions, report bugs, or suggest feature requests. diff --git a/sdk/python/chronosphereio_chronosphere/README.md b/sdk/python/chronosphereio_chronosphere/README.md new file mode 100644 index 00000000..30603e7c --- /dev/null +++ b/sdk/python/chronosphereio_chronosphere/README.md @@ -0,0 +1,4 @@ +> This provider is a derived work of the [Terraform Provider](https://github.com/chronosphereio/terraform-provider-chronosphere) +> 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-chronosphere` repo](https://github.com/chronosphereio/pulumi-chronosphere/issues); however, if that doesn't turn up anything, +> please consult the source [`terraform-provider-chronosphere` repo](https://github.com/chronosphereio/terraform-provider-chronosphere/issues). \ No newline at end of file diff --git a/sdk/python/chronosphereio_chronosphere/__init__.py b/sdk/python/chronosphereio_chronosphere/__init__.py new file mode 100644 index 00000000..2360f05e --- /dev/null +++ b/sdk/python/chronosphereio_chronosphere/__init__.py @@ -0,0 +1,280 @@ +# coding=utf-8 +# *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +from . import _utilities +import typing +# Export this package's modules as members: +from .blackhole_alert_notifier import * +from .bucket import * +from .bucket_data_source import * +from .classic_dashboard import * +from .collection import * +from .dashboard import * +from .derived_label import * +from .derived_metric import * +from .drop_rule import * +from .email_alert_notifier import * +from .gcp_metrics_integration import * +from .grafana_dashboard import * +from .mapping_rule import * +from .monitor import * +from .notification_policy import * +from .notification_policy_data_source import * +from .opsgenie_alert_notifier import * +from .pagerduty_alert_notifier import * +from .provider import * +from .recording_rule import * +from .resource_pools_config import * +from .rollup_rule import * +from .service_account import * +from .service_data_source import * +from .slack_alert_notifier import * +from .team import * +from .trace_jaeger_remote_sampling_strategy import * +from .trace_metrics_rule import * +from .trace_tail_sampling_rules import * +from .victorops_alert_notifier import * +from .webhook_alert_notifier import * +from ._inputs import * +from . import outputs + +# Make subpackages available: +if typing.TYPE_CHECKING: + import chronosphereio_chronosphere.config as __config + config = __config +else: + config = _utilities.lazy_import('chronosphereio_chronosphere.config') + +_utilities.register( + resource_modules=""" +[ + { + "pkg": "chronosphere", + "mod": "index/blackholeAlertNotifier", + "fqn": "chronosphereio_chronosphere", + "classes": { + "chronosphere:index/blackholeAlertNotifier:BlackholeAlertNotifier": "BlackholeAlertNotifier" + } + }, + { + "pkg": "chronosphere", + "mod": "index/bucket", + "fqn": "chronosphereio_chronosphere", + "classes": { + "chronosphere:index/bucket:Bucket": "Bucket" + } + }, + { + "pkg": "chronosphere", + "mod": "index/classicDashboard", + "fqn": "chronosphereio_chronosphere", + "classes": { + "chronosphere:index/classicDashboard:ClassicDashboard": "ClassicDashboard" + } + }, + { + "pkg": "chronosphere", + "mod": "index/collection", + "fqn": "chronosphereio_chronosphere", + "classes": { + "chronosphere:index/collection:Collection": "Collection" + } + }, + { + "pkg": "chronosphere", + "mod": "index/dashboard", + "fqn": "chronosphereio_chronosphere", + "classes": { + "chronosphere:index/dashboard:Dashboard": "Dashboard" + } + }, + { + "pkg": "chronosphere", + "mod": "index/derivedLabel", + "fqn": "chronosphereio_chronosphere", + "classes": { + "chronosphere:index/derivedLabel:DerivedLabel": "DerivedLabel" + } + }, + { + "pkg": "chronosphere", + "mod": "index/derivedMetric", + "fqn": "chronosphereio_chronosphere", + "classes": { + "chronosphere:index/derivedMetric:DerivedMetric": "DerivedMetric" + } + }, + { + "pkg": "chronosphere", + "mod": "index/dropRule", + "fqn": "chronosphereio_chronosphere", + "classes": { + "chronosphere:index/dropRule:DropRule": "DropRule" + } + }, + { + "pkg": "chronosphere", + "mod": "index/emailAlertNotifier", + "fqn": "chronosphereio_chronosphere", + "classes": { + "chronosphere:index/emailAlertNotifier:EmailAlertNotifier": "EmailAlertNotifier" + } + }, + { + "pkg": "chronosphere", + "mod": "index/gcpMetricsIntegration", + "fqn": "chronosphereio_chronosphere", + "classes": { + "chronosphere:index/gcpMetricsIntegration:GcpMetricsIntegration": "GcpMetricsIntegration" + } + }, + { + "pkg": "chronosphere", + "mod": "index/grafanaDashboard", + "fqn": "chronosphereio_chronosphere", + "classes": { + "chronosphere:index/grafanaDashboard:GrafanaDashboard": "GrafanaDashboard" + } + }, + { + "pkg": "chronosphere", + "mod": "index/mappingRule", + "fqn": "chronosphereio_chronosphere", + "classes": { + "chronosphere:index/mappingRule:MappingRule": "MappingRule" + } + }, + { + "pkg": "chronosphere", + "mod": "index/monitor", + "fqn": "chronosphereio_chronosphere", + "classes": { + "chronosphere:index/monitor:Monitor": "Monitor" + } + }, + { + "pkg": "chronosphere", + "mod": "index/notificationPolicy", + "fqn": "chronosphereio_chronosphere", + "classes": { + "chronosphere:index/notificationPolicy:NotificationPolicy": "NotificationPolicy" + } + }, + { + "pkg": "chronosphere", + "mod": "index/opsgenieAlertNotifier", + "fqn": "chronosphereio_chronosphere", + "classes": { + "chronosphere:index/opsgenieAlertNotifier:OpsgenieAlertNotifier": "OpsgenieAlertNotifier" + } + }, + { + "pkg": "chronosphere", + "mod": "index/pagerdutyAlertNotifier", + "fqn": "chronosphereio_chronosphere", + "classes": { + "chronosphere:index/pagerdutyAlertNotifier:PagerdutyAlertNotifier": "PagerdutyAlertNotifier" + } + }, + { + "pkg": "chronosphere", + "mod": "index/recordingRule", + "fqn": "chronosphereio_chronosphere", + "classes": { + "chronosphere:index/recordingRule:RecordingRule": "RecordingRule" + } + }, + { + "pkg": "chronosphere", + "mod": "index/resourcePoolsConfig", + "fqn": "chronosphereio_chronosphere", + "classes": { + "chronosphere:index/resourcePoolsConfig:ResourcePoolsConfig": "ResourcePoolsConfig" + } + }, + { + "pkg": "chronosphere", + "mod": "index/rollupRule", + "fqn": "chronosphereio_chronosphere", + "classes": { + "chronosphere:index/rollupRule:RollupRule": "RollupRule" + } + }, + { + "pkg": "chronosphere", + "mod": "index/serviceAccount", + "fqn": "chronosphereio_chronosphere", + "classes": { + "chronosphere:index/serviceAccount:ServiceAccount": "ServiceAccount" + } + }, + { + "pkg": "chronosphere", + "mod": "index/slackAlertNotifier", + "fqn": "chronosphereio_chronosphere", + "classes": { + "chronosphere:index/slackAlertNotifier:SlackAlertNotifier": "SlackAlertNotifier" + } + }, + { + "pkg": "chronosphere", + "mod": "index/team", + "fqn": "chronosphereio_chronosphere", + "classes": { + "chronosphere:index/team:Team": "Team" + } + }, + { + "pkg": "chronosphere", + "mod": "index/traceJaegerRemoteSamplingStrategy", + "fqn": "chronosphereio_chronosphere", + "classes": { + "chronosphere:index/traceJaegerRemoteSamplingStrategy:TraceJaegerRemoteSamplingStrategy": "TraceJaegerRemoteSamplingStrategy" + } + }, + { + "pkg": "chronosphere", + "mod": "index/traceMetricsRule", + "fqn": "chronosphereio_chronosphere", + "classes": { + "chronosphere:index/traceMetricsRule:TraceMetricsRule": "TraceMetricsRule" + } + }, + { + "pkg": "chronosphere", + "mod": "index/traceTailSamplingRules", + "fqn": "chronosphereio_chronosphere", + "classes": { + "chronosphere:index/traceTailSamplingRules:TraceTailSamplingRules": "TraceTailSamplingRules" + } + }, + { + "pkg": "chronosphere", + "mod": "index/victoropsAlertNotifier", + "fqn": "chronosphereio_chronosphere", + "classes": { + "chronosphere:index/victoropsAlertNotifier:VictoropsAlertNotifier": "VictoropsAlertNotifier" + } + }, + { + "pkg": "chronosphere", + "mod": "index/webhookAlertNotifier", + "fqn": "chronosphereio_chronosphere", + "classes": { + "chronosphere:index/webhookAlertNotifier:WebhookAlertNotifier": "WebhookAlertNotifier" + } + } +] +""", + resource_packages=""" +[ + { + "pkg": "chronosphere", + "token": "pulumi:providers:chronosphere", + "fqn": "chronosphereio_chronosphere", + "class": "Provider" + } +] +""" +) diff --git a/sdk/python/chronosphereio_chronosphere/_inputs.py b/sdk/python/chronosphereio_chronosphere/_inputs.py new file mode 100644 index 00000000..7b4f1f47 --- /dev/null +++ b/sdk/python/chronosphereio_chronosphere/_inputs.py @@ -0,0 +1,3078 @@ +# coding=utf-8 +# *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import copy +import warnings +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +from . import _utilities + +__all__ = [ + 'DerivedLabelMetricLabelArgs', + 'DerivedLabelMetricLabelConstructedLabelArgs', + 'DerivedLabelMetricLabelConstructedLabelValueDefinitionArgs', + 'DerivedLabelMetricLabelConstructedLabelValueDefinitionFilterArgs', + 'DerivedLabelMetricLabelMappingLabelArgs', + 'DerivedLabelMetricLabelMappingLabelNameMappingArgs', + 'DerivedLabelMetricLabelMappingLabelNameMappingFilterArgs', + 'DerivedLabelMetricLabelMappingLabelNameMappingValueMappingArgs', + 'DerivedLabelMetricLabelMappingLabelValueMappingArgs', + 'DerivedMetricQueryArgs', + 'DerivedMetricQueryQueryArgs', + 'DerivedMetricQueryQueryVariableArgs', + 'DerivedMetricQuerySelectorArgs', + 'DropRuleValueBasedDropArgs', + 'GcpMetricsIntegrationMetricGroupArgs', + 'GcpMetricsIntegrationServiceAccountArgs', + 'MappingRuleStoragePolicyArgs', + 'MonitorQueryArgs', + 'MonitorScheduleArgs', + 'MonitorScheduleRangeArgs', + 'MonitorSeriesConditionsArgs', + 'MonitorSeriesConditionsConditionArgs', + 'MonitorSeriesConditionsOverrideArgs', + 'MonitorSeriesConditionsOverrideConditionArgs', + 'MonitorSeriesConditionsOverrideLabelMatcherArgs', + 'MonitorSignalGroupingArgs', + 'NotificationPolicyDataSourceOverrideArgs', + 'NotificationPolicyDataSourceOverrideAlertLabelMatcherArgs', + 'NotificationPolicyDataSourceOverrideRouteArgs', + 'NotificationPolicyDataSourceRouteArgs', + 'NotificationPolicyDataSourceRuleArgs', + 'NotificationPolicyOverrideArgs', + 'NotificationPolicyOverrideAlertLabelMatcherArgs', + 'NotificationPolicyOverrideRouteArgs', + 'NotificationPolicyRouteArgs', + 'NotificationPolicyRuleArgs', + 'OpsgenieAlertNotifierResponderArgs', + 'PagerdutyAlertNotifierImageArgs', + 'PagerdutyAlertNotifierLinkArgs', + 'ResourcePoolsConfigDefaultPoolArgs', + 'ResourcePoolsConfigDefaultPoolAllocationArgs', + 'ResourcePoolsConfigDefaultPoolPrioritiesArgs', + 'ResourcePoolsConfigPoolArgs', + 'ResourcePoolsConfigPoolAllocationArgs', + 'ResourcePoolsConfigPoolPrioritiesArgs', + 'RollupRuleStoragePoliciesArgs', + 'ServiceAccountRestrictionArgs', + 'SlackAlertNotifierActionArgs', + 'SlackAlertNotifierFieldArgs', + 'TraceJaegerRemoteSamplingStrategyAppliedStrategyArgs', + 'TraceJaegerRemoteSamplingStrategyAppliedStrategyPerOperationStrategiesArgs', + 'TraceJaegerRemoteSamplingStrategyAppliedStrategyPerOperationStrategiesPerOperationStrategyArgs', + 'TraceJaegerRemoteSamplingStrategyAppliedStrategyPerOperationStrategiesPerOperationStrategyProbabilisticStrategyArgs', + 'TraceJaegerRemoteSamplingStrategyAppliedStrategyProbabilisticStrategyArgs', + 'TraceJaegerRemoteSamplingStrategyAppliedStrategyRateLimitingStrategyArgs', + 'TraceMetricsRuleGroupByArgs', + 'TraceMetricsRuleGroupByKeyArgs', + 'TraceMetricsRuleTraceFilterArgs', + 'TraceMetricsRuleTraceFilterSpanArgs', + 'TraceMetricsRuleTraceFilterSpanDurationArgs', + 'TraceMetricsRuleTraceFilterSpanErrorArgs', + 'TraceMetricsRuleTraceFilterSpanOperationArgs', + 'TraceMetricsRuleTraceFilterSpanParentOperationArgs', + 'TraceMetricsRuleTraceFilterSpanParentServiceArgs', + 'TraceMetricsRuleTraceFilterSpanServiceArgs', + 'TraceMetricsRuleTraceFilterSpanSpanCountArgs', + 'TraceMetricsRuleTraceFilterSpanTagArgs', + 'TraceMetricsRuleTraceFilterSpanTagNumericValueArgs', + 'TraceMetricsRuleTraceFilterSpanTagValueArgs', + 'TraceMetricsRuleTraceFilterTraceArgs', + 'TraceMetricsRuleTraceFilterTraceDurationArgs', + 'TraceMetricsRuleTraceFilterTraceErrorArgs', + 'TraceTailSamplingRulesDefaultSampleRateArgs', + 'TraceTailSamplingRulesRuleArgs', + 'TraceTailSamplingRulesRuleFilterArgs', + 'TraceTailSamplingRulesRuleFilterSpanArgs', + 'TraceTailSamplingRulesRuleFilterSpanDurationArgs', + 'TraceTailSamplingRulesRuleFilterSpanErrorArgs', + 'TraceTailSamplingRulesRuleFilterSpanOperationArgs', + 'TraceTailSamplingRulesRuleFilterSpanParentOperationArgs', + 'TraceTailSamplingRulesRuleFilterSpanParentServiceArgs', + 'TraceTailSamplingRulesRuleFilterSpanServiceArgs', + 'TraceTailSamplingRulesRuleFilterSpanSpanCountArgs', + 'TraceTailSamplingRulesRuleFilterSpanTagArgs', + 'TraceTailSamplingRulesRuleFilterSpanTagNumericValueArgs', + 'TraceTailSamplingRulesRuleFilterSpanTagValueArgs', + 'TraceTailSamplingRulesRuleFilterTraceArgs', + 'TraceTailSamplingRulesRuleFilterTraceDurationArgs', + 'TraceTailSamplingRulesRuleFilterTraceErrorArgs', +] + +@pulumi.input_type +class DerivedLabelMetricLabelArgs: + def __init__(__self__, *, + constructed_label: Optional[pulumi.Input['DerivedLabelMetricLabelConstructedLabelArgs']] = None, + mapping_label: Optional[pulumi.Input['DerivedLabelMetricLabelMappingLabelArgs']] = None): + if constructed_label is not None: + pulumi.set(__self__, "constructed_label", constructed_label) + if mapping_label is not None: + pulumi.set(__self__, "mapping_label", mapping_label) + + @property + @pulumi.getter(name="constructedLabel") + def constructed_label(self) -> Optional[pulumi.Input['DerivedLabelMetricLabelConstructedLabelArgs']]: + return pulumi.get(self, "constructed_label") + + @constructed_label.setter + def constructed_label(self, value: Optional[pulumi.Input['DerivedLabelMetricLabelConstructedLabelArgs']]): + pulumi.set(self, "constructed_label", value) + + @property + @pulumi.getter(name="mappingLabel") + def mapping_label(self) -> Optional[pulumi.Input['DerivedLabelMetricLabelMappingLabelArgs']]: + return pulumi.get(self, "mapping_label") + + @mapping_label.setter + def mapping_label(self, value: Optional[pulumi.Input['DerivedLabelMetricLabelMappingLabelArgs']]): + pulumi.set(self, "mapping_label", value) + + +@pulumi.input_type +class DerivedLabelMetricLabelConstructedLabelArgs: + def __init__(__self__, *, + value_definitions: pulumi.Input[Sequence[pulumi.Input['DerivedLabelMetricLabelConstructedLabelValueDefinitionArgs']]]): + pulumi.set(__self__, "value_definitions", value_definitions) + + @property + @pulumi.getter(name="valueDefinitions") + def value_definitions(self) -> pulumi.Input[Sequence[pulumi.Input['DerivedLabelMetricLabelConstructedLabelValueDefinitionArgs']]]: + return pulumi.get(self, "value_definitions") + + @value_definitions.setter + def value_definitions(self, value: pulumi.Input[Sequence[pulumi.Input['DerivedLabelMetricLabelConstructedLabelValueDefinitionArgs']]]): + pulumi.set(self, "value_definitions", value) + + +@pulumi.input_type +class DerivedLabelMetricLabelConstructedLabelValueDefinitionArgs: + def __init__(__self__, *, + filters: pulumi.Input[Sequence[pulumi.Input['DerivedLabelMetricLabelConstructedLabelValueDefinitionFilterArgs']]], + value: pulumi.Input[str]): + pulumi.set(__self__, "filters", filters) + pulumi.set(__self__, "value", value) + + @property + @pulumi.getter + def filters(self) -> pulumi.Input[Sequence[pulumi.Input['DerivedLabelMetricLabelConstructedLabelValueDefinitionFilterArgs']]]: + return pulumi.get(self, "filters") + + @filters.setter + def filters(self, value: pulumi.Input[Sequence[pulumi.Input['DerivedLabelMetricLabelConstructedLabelValueDefinitionFilterArgs']]]): + pulumi.set(self, "filters", value) + + @property + @pulumi.getter + def value(self) -> pulumi.Input[str]: + return pulumi.get(self, "value") + + @value.setter + def value(self, value: pulumi.Input[str]): + pulumi.set(self, "value", value) + + +@pulumi.input_type +class DerivedLabelMetricLabelConstructedLabelValueDefinitionFilterArgs: + def __init__(__self__, *, + name: pulumi.Input[str], + value_glob: pulumi.Input[str]): + pulumi.set(__self__, "name", name) + pulumi.set(__self__, "value_glob", value_glob) + + @property + @pulumi.getter + def name(self) -> pulumi.Input[str]: + return pulumi.get(self, "name") + + @name.setter + def name(self, value: pulumi.Input[str]): + pulumi.set(self, "name", value) + + @property + @pulumi.getter(name="valueGlob") + def value_glob(self) -> pulumi.Input[str]: + return pulumi.get(self, "value_glob") + + @value_glob.setter + def value_glob(self, value: pulumi.Input[str]): + pulumi.set(self, "value_glob", value) + + +@pulumi.input_type +class DerivedLabelMetricLabelMappingLabelArgs: + def __init__(__self__, *, + name_mappings: Optional[pulumi.Input[Sequence[pulumi.Input['DerivedLabelMetricLabelMappingLabelNameMappingArgs']]]] = None, + value_mappings: Optional[pulumi.Input[Sequence[pulumi.Input['DerivedLabelMetricLabelMappingLabelValueMappingArgs']]]] = None): + if name_mappings is not None: + pulumi.set(__self__, "name_mappings", name_mappings) + if value_mappings is not None: + pulumi.set(__self__, "value_mappings", value_mappings) + + @property + @pulumi.getter(name="nameMappings") + def name_mappings(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['DerivedLabelMetricLabelMappingLabelNameMappingArgs']]]]: + return pulumi.get(self, "name_mappings") + + @name_mappings.setter + def name_mappings(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['DerivedLabelMetricLabelMappingLabelNameMappingArgs']]]]): + pulumi.set(self, "name_mappings", value) + + @property + @pulumi.getter(name="valueMappings") + def value_mappings(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['DerivedLabelMetricLabelMappingLabelValueMappingArgs']]]]: + return pulumi.get(self, "value_mappings") + + @value_mappings.setter + def value_mappings(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['DerivedLabelMetricLabelMappingLabelValueMappingArgs']]]]): + pulumi.set(self, "value_mappings", value) + + +@pulumi.input_type +class DerivedLabelMetricLabelMappingLabelNameMappingArgs: + def __init__(__self__, *, + filters: pulumi.Input[Sequence[pulumi.Input['DerivedLabelMetricLabelMappingLabelNameMappingFilterArgs']]], + source_label: pulumi.Input[str], + value_mappings: Optional[pulumi.Input[Sequence[pulumi.Input['DerivedLabelMetricLabelMappingLabelNameMappingValueMappingArgs']]]] = None): + pulumi.set(__self__, "filters", filters) + pulumi.set(__self__, "source_label", source_label) + if value_mappings is not None: + pulumi.set(__self__, "value_mappings", value_mappings) + + @property + @pulumi.getter + def filters(self) -> pulumi.Input[Sequence[pulumi.Input['DerivedLabelMetricLabelMappingLabelNameMappingFilterArgs']]]: + return pulumi.get(self, "filters") + + @filters.setter + def filters(self, value: pulumi.Input[Sequence[pulumi.Input['DerivedLabelMetricLabelMappingLabelNameMappingFilterArgs']]]): + pulumi.set(self, "filters", value) + + @property + @pulumi.getter(name="sourceLabel") + def source_label(self) -> pulumi.Input[str]: + return pulumi.get(self, "source_label") + + @source_label.setter + def source_label(self, value: pulumi.Input[str]): + pulumi.set(self, "source_label", value) + + @property + @pulumi.getter(name="valueMappings") + def value_mappings(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['DerivedLabelMetricLabelMappingLabelNameMappingValueMappingArgs']]]]: + return pulumi.get(self, "value_mappings") + + @value_mappings.setter + def value_mappings(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['DerivedLabelMetricLabelMappingLabelNameMappingValueMappingArgs']]]]): + pulumi.set(self, "value_mappings", value) + + +@pulumi.input_type +class DerivedLabelMetricLabelMappingLabelNameMappingFilterArgs: + def __init__(__self__, *, + name: pulumi.Input[str], + value_glob: pulumi.Input[str]): + pulumi.set(__self__, "name", name) + pulumi.set(__self__, "value_glob", value_glob) + + @property + @pulumi.getter + def name(self) -> pulumi.Input[str]: + return pulumi.get(self, "name") + + @name.setter + def name(self, value: pulumi.Input[str]): + pulumi.set(self, "name", value) + + @property + @pulumi.getter(name="valueGlob") + def value_glob(self) -> pulumi.Input[str]: + return pulumi.get(self, "value_glob") + + @value_glob.setter + def value_glob(self, value: pulumi.Input[str]): + pulumi.set(self, "value_glob", value) + + +@pulumi.input_type +class DerivedLabelMetricLabelMappingLabelNameMappingValueMappingArgs: + def __init__(__self__, *, + source_value_globs: pulumi.Input[Sequence[pulumi.Input[str]]], + target_value: pulumi.Input[str]): + pulumi.set(__self__, "source_value_globs", source_value_globs) + pulumi.set(__self__, "target_value", target_value) + + @property + @pulumi.getter(name="sourceValueGlobs") + def source_value_globs(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]: + return pulumi.get(self, "source_value_globs") + + @source_value_globs.setter + def source_value_globs(self, value: pulumi.Input[Sequence[pulumi.Input[str]]]): + pulumi.set(self, "source_value_globs", value) + + @property + @pulumi.getter(name="targetValue") + def target_value(self) -> pulumi.Input[str]: + return pulumi.get(self, "target_value") + + @target_value.setter + def target_value(self, value: pulumi.Input[str]): + pulumi.set(self, "target_value", value) + + +@pulumi.input_type +class DerivedLabelMetricLabelMappingLabelValueMappingArgs: + def __init__(__self__, *, + source_value_globs: pulumi.Input[Sequence[pulumi.Input[str]]], + target_value: pulumi.Input[str]): + pulumi.set(__self__, "source_value_globs", source_value_globs) + pulumi.set(__self__, "target_value", target_value) + + @property + @pulumi.getter(name="sourceValueGlobs") + def source_value_globs(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]: + return pulumi.get(self, "source_value_globs") + + @source_value_globs.setter + def source_value_globs(self, value: pulumi.Input[Sequence[pulumi.Input[str]]]): + pulumi.set(self, "source_value_globs", value) + + @property + @pulumi.getter(name="targetValue") + def target_value(self) -> pulumi.Input[str]: + return pulumi.get(self, "target_value") + + @target_value.setter + def target_value(self, value: pulumi.Input[str]): + pulumi.set(self, "target_value", value) + + +@pulumi.input_type +class DerivedMetricQueryArgs: + def __init__(__self__, *, + query: pulumi.Input['DerivedMetricQueryQueryArgs'], + selector: Optional[pulumi.Input['DerivedMetricQuerySelectorArgs']] = None): + pulumi.set(__self__, "query", query) + if selector is not None: + pulumi.set(__self__, "selector", selector) + + @property + @pulumi.getter + def query(self) -> pulumi.Input['DerivedMetricQueryQueryArgs']: + return pulumi.get(self, "query") + + @query.setter + def query(self, value: pulumi.Input['DerivedMetricQueryQueryArgs']): + pulumi.set(self, "query", value) + + @property + @pulumi.getter + def selector(self) -> Optional[pulumi.Input['DerivedMetricQuerySelectorArgs']]: + return pulumi.get(self, "selector") + + @selector.setter + def selector(self, value: Optional[pulumi.Input['DerivedMetricQuerySelectorArgs']]): + pulumi.set(self, "selector", value) + + +@pulumi.input_type +class DerivedMetricQueryQueryArgs: + def __init__(__self__, *, + expr: pulumi.Input[str], + variables: Optional[pulumi.Input[Sequence[pulumi.Input['DerivedMetricQueryQueryVariableArgs']]]] = None): + pulumi.set(__self__, "expr", expr) + if variables is not None: + pulumi.set(__self__, "variables", variables) + + @property + @pulumi.getter + def expr(self) -> pulumi.Input[str]: + return pulumi.get(self, "expr") + + @expr.setter + def expr(self, value: pulumi.Input[str]): + pulumi.set(self, "expr", value) + + @property + @pulumi.getter + def variables(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['DerivedMetricQueryQueryVariableArgs']]]]: + return pulumi.get(self, "variables") + + @variables.setter + def variables(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['DerivedMetricQueryQueryVariableArgs']]]]): + pulumi.set(self, "variables", value) + + +@pulumi.input_type +class DerivedMetricQueryQueryVariableArgs: + def __init__(__self__, *, + default_selector: pulumi.Input[str], + name: pulumi.Input[str]): + pulumi.set(__self__, "default_selector", default_selector) + pulumi.set(__self__, "name", name) + + @property + @pulumi.getter(name="defaultSelector") + def default_selector(self) -> pulumi.Input[str]: + return pulumi.get(self, "default_selector") + + @default_selector.setter + def default_selector(self, value: pulumi.Input[str]): + pulumi.set(self, "default_selector", value) + + @property + @pulumi.getter + def name(self) -> pulumi.Input[str]: + return pulumi.get(self, "name") + + @name.setter + def name(self, value: pulumi.Input[str]): + pulumi.set(self, "name", value) + + +@pulumi.input_type +class DerivedMetricQuerySelectorArgs: + def __init__(__self__, *, + labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None): + if labels is not None: + pulumi.set(__self__, "labels", labels) + + @property + @pulumi.getter + def labels(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]: + return pulumi.get(self, "labels") + + @labels.setter + def labels(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]): + pulumi.set(self, "labels", value) + + +@pulumi.input_type +class DropRuleValueBasedDropArgs: + def __init__(__self__, *, + target_drop_value: pulumi.Input[float]): + pulumi.set(__self__, "target_drop_value", target_drop_value) + + @property + @pulumi.getter(name="targetDropValue") + def target_drop_value(self) -> pulumi.Input[float]: + return pulumi.get(self, "target_drop_value") + + @target_drop_value.setter + def target_drop_value(self, value: pulumi.Input[float]): + pulumi.set(self, "target_drop_value", value) + + +@pulumi.input_type +class GcpMetricsIntegrationMetricGroupArgs: + def __init__(__self__, *, + project_id: pulumi.Input[str], + prefixes: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None): + pulumi.set(__self__, "project_id", project_id) + if prefixes is not None: + pulumi.set(__self__, "prefixes", prefixes) + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> pulumi.Input[str]: + return pulumi.get(self, "project_id") + + @project_id.setter + def project_id(self, value: pulumi.Input[str]): + pulumi.set(self, "project_id", value) + + @property + @pulumi.getter + def prefixes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]: + return pulumi.get(self, "prefixes") + + @prefixes.setter + def prefixes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]): + pulumi.set(self, "prefixes", value) + + +@pulumi.input_type +class GcpMetricsIntegrationServiceAccountArgs: + def __init__(__self__, *, + client_email: pulumi.Input[str]): + pulumi.set(__self__, "client_email", client_email) + + @property + @pulumi.getter(name="clientEmail") + def client_email(self) -> pulumi.Input[str]: + return pulumi.get(self, "client_email") + + @client_email.setter + def client_email(self, value: pulumi.Input[str]): + pulumi.set(self, "client_email", value) + + +@pulumi.input_type +class MappingRuleStoragePolicyArgs: + def __init__(__self__, *, + resolution: pulumi.Input[str], + retention: pulumi.Input[str]): + pulumi.set(__self__, "resolution", resolution) + pulumi.set(__self__, "retention", retention) + + @property + @pulumi.getter + def resolution(self) -> pulumi.Input[str]: + return pulumi.get(self, "resolution") + + @resolution.setter + def resolution(self, value: pulumi.Input[str]): + pulumi.set(self, "resolution", value) + + @property + @pulumi.getter + def retention(self) -> pulumi.Input[str]: + return pulumi.get(self, "retention") + + @retention.setter + def retention(self, value: pulumi.Input[str]): + pulumi.set(self, "retention", value) + + +@pulumi.input_type +class MonitorQueryArgs: + def __init__(__self__, *, + graphite_expr: Optional[pulumi.Input[str]] = None, + prometheus_expr: Optional[pulumi.Input[str]] = None): + if graphite_expr is not None: + pulumi.set(__self__, "graphite_expr", graphite_expr) + if prometheus_expr is not None: + pulumi.set(__self__, "prometheus_expr", prometheus_expr) + + @property + @pulumi.getter(name="graphiteExpr") + def graphite_expr(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "graphite_expr") + + @graphite_expr.setter + def graphite_expr(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "graphite_expr", value) + + @property + @pulumi.getter(name="prometheusExpr") + def prometheus_expr(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "prometheus_expr") + + @prometheus_expr.setter + def prometheus_expr(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "prometheus_expr", value) + + +@pulumi.input_type +class MonitorScheduleArgs: + def __init__(__self__, *, + timezone: pulumi.Input[str], + ranges: Optional[pulumi.Input[Sequence[pulumi.Input['MonitorScheduleRangeArgs']]]] = None): + pulumi.set(__self__, "timezone", timezone) + if ranges is not None: + pulumi.set(__self__, "ranges", ranges) + + @property + @pulumi.getter + def timezone(self) -> pulumi.Input[str]: + return pulumi.get(self, "timezone") + + @timezone.setter + def timezone(self, value: pulumi.Input[str]): + pulumi.set(self, "timezone", value) + + @property + @pulumi.getter + def ranges(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['MonitorScheduleRangeArgs']]]]: + return pulumi.get(self, "ranges") + + @ranges.setter + def ranges(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['MonitorScheduleRangeArgs']]]]): + pulumi.set(self, "ranges", value) + + +@pulumi.input_type +class MonitorScheduleRangeArgs: + def __init__(__self__, *, + day: pulumi.Input[str], + end: pulumi.Input[str], + start: pulumi.Input[str]): + pulumi.set(__self__, "day", day) + pulumi.set(__self__, "end", end) + pulumi.set(__self__, "start", start) + + @property + @pulumi.getter + def day(self) -> pulumi.Input[str]: + return pulumi.get(self, "day") + + @day.setter + def day(self, value: pulumi.Input[str]): + pulumi.set(self, "day", value) + + @property + @pulumi.getter + def end(self) -> pulumi.Input[str]: + return pulumi.get(self, "end") + + @end.setter + def end(self, value: pulumi.Input[str]): + pulumi.set(self, "end", value) + + @property + @pulumi.getter + def start(self) -> pulumi.Input[str]: + return pulumi.get(self, "start") + + @start.setter + def start(self, value: pulumi.Input[str]): + pulumi.set(self, "start", value) + + +@pulumi.input_type +class MonitorSeriesConditionsArgs: + def __init__(__self__, *, + conditions: pulumi.Input[Sequence[pulumi.Input['MonitorSeriesConditionsConditionArgs']]], + overrides: Optional[pulumi.Input[Sequence[pulumi.Input['MonitorSeriesConditionsOverrideArgs']]]] = None): + pulumi.set(__self__, "conditions", conditions) + if overrides is not None: + pulumi.set(__self__, "overrides", overrides) + + @property + @pulumi.getter + def conditions(self) -> pulumi.Input[Sequence[pulumi.Input['MonitorSeriesConditionsConditionArgs']]]: + return pulumi.get(self, "conditions") + + @conditions.setter + def conditions(self, value: pulumi.Input[Sequence[pulumi.Input['MonitorSeriesConditionsConditionArgs']]]): + pulumi.set(self, "conditions", value) + + @property + @pulumi.getter + def overrides(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['MonitorSeriesConditionsOverrideArgs']]]]: + return pulumi.get(self, "overrides") + + @overrides.setter + def overrides(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['MonitorSeriesConditionsOverrideArgs']]]]): + pulumi.set(self, "overrides", value) + + +@pulumi.input_type +class MonitorSeriesConditionsConditionArgs: + def __init__(__self__, *, + op: pulumi.Input[str], + severity: pulumi.Input[str], + resolve_sustain: Optional[pulumi.Input[str]] = None, + sustain: Optional[pulumi.Input[str]] = None, + value: Optional[pulumi.Input[float]] = None): + pulumi.set(__self__, "op", op) + pulumi.set(__self__, "severity", severity) + if resolve_sustain is not None: + pulumi.set(__self__, "resolve_sustain", resolve_sustain) + if sustain is not None: + pulumi.set(__self__, "sustain", sustain) + if value is not None: + pulumi.set(__self__, "value", value) + + @property + @pulumi.getter + def op(self) -> pulumi.Input[str]: + return pulumi.get(self, "op") + + @op.setter + def op(self, value: pulumi.Input[str]): + pulumi.set(self, "op", value) + + @property + @pulumi.getter + def severity(self) -> pulumi.Input[str]: + return pulumi.get(self, "severity") + + @severity.setter + def severity(self, value: pulumi.Input[str]): + pulumi.set(self, "severity", value) + + @property + @pulumi.getter(name="resolveSustain") + def resolve_sustain(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "resolve_sustain") + + @resolve_sustain.setter + def resolve_sustain(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "resolve_sustain", value) + + @property + @pulumi.getter + def sustain(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "sustain") + + @sustain.setter + def sustain(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "sustain", value) + + @property + @pulumi.getter + def value(self) -> Optional[pulumi.Input[float]]: + return pulumi.get(self, "value") + + @value.setter + def value(self, value: Optional[pulumi.Input[float]]): + pulumi.set(self, "value", value) + + +@pulumi.input_type +class MonitorSeriesConditionsOverrideArgs: + def __init__(__self__, *, + conditions: pulumi.Input[Sequence[pulumi.Input['MonitorSeriesConditionsOverrideConditionArgs']]], + label_matchers: pulumi.Input[Sequence[pulumi.Input['MonitorSeriesConditionsOverrideLabelMatcherArgs']]]): + pulumi.set(__self__, "conditions", conditions) + pulumi.set(__self__, "label_matchers", label_matchers) + + @property + @pulumi.getter + def conditions(self) -> pulumi.Input[Sequence[pulumi.Input['MonitorSeriesConditionsOverrideConditionArgs']]]: + return pulumi.get(self, "conditions") + + @conditions.setter + def conditions(self, value: pulumi.Input[Sequence[pulumi.Input['MonitorSeriesConditionsOverrideConditionArgs']]]): + pulumi.set(self, "conditions", value) + + @property + @pulumi.getter(name="labelMatchers") + def label_matchers(self) -> pulumi.Input[Sequence[pulumi.Input['MonitorSeriesConditionsOverrideLabelMatcherArgs']]]: + return pulumi.get(self, "label_matchers") + + @label_matchers.setter + def label_matchers(self, value: pulumi.Input[Sequence[pulumi.Input['MonitorSeriesConditionsOverrideLabelMatcherArgs']]]): + pulumi.set(self, "label_matchers", value) + + +@pulumi.input_type +class MonitorSeriesConditionsOverrideConditionArgs: + def __init__(__self__, *, + op: pulumi.Input[str], + severity: pulumi.Input[str], + resolve_sustain: Optional[pulumi.Input[str]] = None, + sustain: Optional[pulumi.Input[str]] = None, + value: Optional[pulumi.Input[float]] = None): + pulumi.set(__self__, "op", op) + pulumi.set(__self__, "severity", severity) + if resolve_sustain is not None: + pulumi.set(__self__, "resolve_sustain", resolve_sustain) + if sustain is not None: + pulumi.set(__self__, "sustain", sustain) + if value is not None: + pulumi.set(__self__, "value", value) + + @property + @pulumi.getter + def op(self) -> pulumi.Input[str]: + return pulumi.get(self, "op") + + @op.setter + def op(self, value: pulumi.Input[str]): + pulumi.set(self, "op", value) + + @property + @pulumi.getter + def severity(self) -> pulumi.Input[str]: + return pulumi.get(self, "severity") + + @severity.setter + def severity(self, value: pulumi.Input[str]): + pulumi.set(self, "severity", value) + + @property + @pulumi.getter(name="resolveSustain") + def resolve_sustain(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "resolve_sustain") + + @resolve_sustain.setter + def resolve_sustain(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "resolve_sustain", value) + + @property + @pulumi.getter + def sustain(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "sustain") + + @sustain.setter + def sustain(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "sustain", value) + + @property + @pulumi.getter + def value(self) -> Optional[pulumi.Input[float]]: + return pulumi.get(self, "value") + + @value.setter + def value(self, value: Optional[pulumi.Input[float]]): + pulumi.set(self, "value", value) + + +@pulumi.input_type +class MonitorSeriesConditionsOverrideLabelMatcherArgs: + def __init__(__self__, *, + name: pulumi.Input[str], + type: pulumi.Input[str], + value: pulumi.Input[str]): + pulumi.set(__self__, "name", name) + pulumi.set(__self__, "type", type) + pulumi.set(__self__, "value", value) + + @property + @pulumi.getter + def name(self) -> pulumi.Input[str]: + return pulumi.get(self, "name") + + @name.setter + def name(self, value: pulumi.Input[str]): + pulumi.set(self, "name", value) + + @property + @pulumi.getter + def type(self) -> pulumi.Input[str]: + return pulumi.get(self, "type") + + @type.setter + def type(self, value: pulumi.Input[str]): + pulumi.set(self, "type", value) + + @property + @pulumi.getter + def value(self) -> pulumi.Input[str]: + return pulumi.get(self, "value") + + @value.setter + def value(self, value: pulumi.Input[str]): + pulumi.set(self, "value", value) + + +@pulumi.input_type +class MonitorSignalGroupingArgs: + def __init__(__self__, *, + label_names: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None, + signal_per_series: Optional[pulumi.Input[bool]] = None): + if label_names is not None: + pulumi.set(__self__, "label_names", label_names) + if signal_per_series is not None: + pulumi.set(__self__, "signal_per_series", signal_per_series) + + @property + @pulumi.getter(name="labelNames") + def label_names(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]: + return pulumi.get(self, "label_names") + + @label_names.setter + def label_names(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]): + pulumi.set(self, "label_names", value) + + @property + @pulumi.getter(name="signalPerSeries") + def signal_per_series(self) -> Optional[pulumi.Input[bool]]: + return pulumi.get(self, "signal_per_series") + + @signal_per_series.setter + def signal_per_series(self, value: Optional[pulumi.Input[bool]]): + pulumi.set(self, "signal_per_series", value) + + +@pulumi.input_type +class NotificationPolicyDataSourceOverrideArgs: + def __init__(__self__, *, + alert_label_matchers: Sequence['NotificationPolicyDataSourceOverrideAlertLabelMatcherArgs'], + routes: Optional[Sequence['NotificationPolicyDataSourceOverrideRouteArgs']] = None): + pulumi.set(__self__, "alert_label_matchers", alert_label_matchers) + if routes is not None: + pulumi.set(__self__, "routes", routes) + + @property + @pulumi.getter(name="alertLabelMatchers") + def alert_label_matchers(self) -> Sequence['NotificationPolicyDataSourceOverrideAlertLabelMatcherArgs']: + return pulumi.get(self, "alert_label_matchers") + + @alert_label_matchers.setter + def alert_label_matchers(self, value: Sequence['NotificationPolicyDataSourceOverrideAlertLabelMatcherArgs']): + pulumi.set(self, "alert_label_matchers", value) + + @property + @pulumi.getter + def routes(self) -> Optional[Sequence['NotificationPolicyDataSourceOverrideRouteArgs']]: + return pulumi.get(self, "routes") + + @routes.setter + def routes(self, value: Optional[Sequence['NotificationPolicyDataSourceOverrideRouteArgs']]): + pulumi.set(self, "routes", value) + + +@pulumi.input_type +class NotificationPolicyDataSourceOverrideAlertLabelMatcherArgs: + def __init__(__self__, *, + name: str, + type: str, + value: str): + pulumi.set(__self__, "name", name) + pulumi.set(__self__, "type", type) + pulumi.set(__self__, "value", value) + + @property + @pulumi.getter + def name(self) -> str: + return pulumi.get(self, "name") + + @name.setter + def name(self, value: str): + pulumi.set(self, "name", value) + + @property + @pulumi.getter + def type(self) -> str: + return pulumi.get(self, "type") + + @type.setter + def type(self, value: str): + pulumi.set(self, "type", value) + + @property + @pulumi.getter + def value(self) -> str: + return pulumi.get(self, "value") + + @value.setter + def value(self, value: str): + pulumi.set(self, "value", value) + + +@pulumi.input_type +class NotificationPolicyDataSourceOverrideRouteArgs: + def __init__(__self__, *, + severity: str, + notifiers: Optional[Sequence[str]] = None, + repeat_interval: Optional[str] = None): + pulumi.set(__self__, "severity", severity) + if notifiers is not None: + pulumi.set(__self__, "notifiers", notifiers) + if repeat_interval is not None: + pulumi.set(__self__, "repeat_interval", repeat_interval) + + @property + @pulumi.getter + def severity(self) -> str: + return pulumi.get(self, "severity") + + @severity.setter + def severity(self, value: str): + pulumi.set(self, "severity", value) + + @property + @pulumi.getter + def notifiers(self) -> Optional[Sequence[str]]: + return pulumi.get(self, "notifiers") + + @notifiers.setter + def notifiers(self, value: Optional[Sequence[str]]): + pulumi.set(self, "notifiers", value) + + @property + @pulumi.getter(name="repeatInterval") + def repeat_interval(self) -> Optional[str]: + return pulumi.get(self, "repeat_interval") + + @repeat_interval.setter + def repeat_interval(self, value: Optional[str]): + pulumi.set(self, "repeat_interval", value) + + +@pulumi.input_type +class NotificationPolicyDataSourceRouteArgs: + def __init__(__self__, *, + severity: str, + notifiers: Optional[Sequence[str]] = None, + repeat_interval: Optional[str] = None): + pulumi.set(__self__, "severity", severity) + if notifiers is not None: + pulumi.set(__self__, "notifiers", notifiers) + if repeat_interval is not None: + pulumi.set(__self__, "repeat_interval", repeat_interval) + + @property + @pulumi.getter + def severity(self) -> str: + return pulumi.get(self, "severity") + + @severity.setter + def severity(self, value: str): + pulumi.set(self, "severity", value) + + @property + @pulumi.getter + def notifiers(self) -> Optional[Sequence[str]]: + return pulumi.get(self, "notifiers") + + @notifiers.setter + def notifiers(self, value: Optional[Sequence[str]]): + pulumi.set(self, "notifiers", value) + + @property + @pulumi.getter(name="repeatInterval") + def repeat_interval(self) -> Optional[str]: + return pulumi.get(self, "repeat_interval") + + @repeat_interval.setter + def repeat_interval(self, value: Optional[str]): + pulumi.set(self, "repeat_interval", value) + + +@pulumi.input_type +class NotificationPolicyDataSourceRuleArgs: + def __init__(__self__, *, + severity: str, + notifiers: Optional[Sequence[str]] = None, + repeat_interval: Optional[str] = None): + pulumi.set(__self__, "severity", severity) + if notifiers is not None: + pulumi.set(__self__, "notifiers", notifiers) + if repeat_interval is not None: + pulumi.set(__self__, "repeat_interval", repeat_interval) + + @property + @pulumi.getter + def severity(self) -> str: + return pulumi.get(self, "severity") + + @severity.setter + def severity(self, value: str): + pulumi.set(self, "severity", value) + + @property + @pulumi.getter + def notifiers(self) -> Optional[Sequence[str]]: + return pulumi.get(self, "notifiers") + + @notifiers.setter + def notifiers(self, value: Optional[Sequence[str]]): + pulumi.set(self, "notifiers", value) + + @property + @pulumi.getter(name="repeatInterval") + def repeat_interval(self) -> Optional[str]: + return pulumi.get(self, "repeat_interval") + + @repeat_interval.setter + def repeat_interval(self, value: Optional[str]): + pulumi.set(self, "repeat_interval", value) + + +@pulumi.input_type +class NotificationPolicyOverrideArgs: + def __init__(__self__, *, + alert_label_matchers: pulumi.Input[Sequence[pulumi.Input['NotificationPolicyOverrideAlertLabelMatcherArgs']]], + routes: Optional[pulumi.Input[Sequence[pulumi.Input['NotificationPolicyOverrideRouteArgs']]]] = None): + pulumi.set(__self__, "alert_label_matchers", alert_label_matchers) + if routes is not None: + pulumi.set(__self__, "routes", routes) + + @property + @pulumi.getter(name="alertLabelMatchers") + def alert_label_matchers(self) -> pulumi.Input[Sequence[pulumi.Input['NotificationPolicyOverrideAlertLabelMatcherArgs']]]: + return pulumi.get(self, "alert_label_matchers") + + @alert_label_matchers.setter + def alert_label_matchers(self, value: pulumi.Input[Sequence[pulumi.Input['NotificationPolicyOverrideAlertLabelMatcherArgs']]]): + pulumi.set(self, "alert_label_matchers", value) + + @property + @pulumi.getter + def routes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['NotificationPolicyOverrideRouteArgs']]]]: + return pulumi.get(self, "routes") + + @routes.setter + def routes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['NotificationPolicyOverrideRouteArgs']]]]): + pulumi.set(self, "routes", value) + + +@pulumi.input_type +class NotificationPolicyOverrideAlertLabelMatcherArgs: + def __init__(__self__, *, + name: pulumi.Input[str], + type: pulumi.Input[str], + value: pulumi.Input[str]): + pulumi.set(__self__, "name", name) + pulumi.set(__self__, "type", type) + pulumi.set(__self__, "value", value) + + @property + @pulumi.getter + def name(self) -> pulumi.Input[str]: + return pulumi.get(self, "name") + + @name.setter + def name(self, value: pulumi.Input[str]): + pulumi.set(self, "name", value) + + @property + @pulumi.getter + def type(self) -> pulumi.Input[str]: + return pulumi.get(self, "type") + + @type.setter + def type(self, value: pulumi.Input[str]): + pulumi.set(self, "type", value) + + @property + @pulumi.getter + def value(self) -> pulumi.Input[str]: + return pulumi.get(self, "value") + + @value.setter + def value(self, value: pulumi.Input[str]): + pulumi.set(self, "value", value) + + +@pulumi.input_type +class NotificationPolicyOverrideRouteArgs: + def __init__(__self__, *, + severity: pulumi.Input[str], + notifiers: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None, + repeat_interval: Optional[pulumi.Input[str]] = None): + pulumi.set(__self__, "severity", severity) + if notifiers is not None: + pulumi.set(__self__, "notifiers", notifiers) + if repeat_interval is not None: + pulumi.set(__self__, "repeat_interval", repeat_interval) + + @property + @pulumi.getter + def severity(self) -> pulumi.Input[str]: + return pulumi.get(self, "severity") + + @severity.setter + def severity(self, value: pulumi.Input[str]): + pulumi.set(self, "severity", value) + + @property + @pulumi.getter + def notifiers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]: + return pulumi.get(self, "notifiers") + + @notifiers.setter + def notifiers(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]): + pulumi.set(self, "notifiers", value) + + @property + @pulumi.getter(name="repeatInterval") + def repeat_interval(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "repeat_interval") + + @repeat_interval.setter + def repeat_interval(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "repeat_interval", value) + + +@pulumi.input_type +class NotificationPolicyRouteArgs: + def __init__(__self__, *, + severity: pulumi.Input[str], + notifiers: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None, + repeat_interval: Optional[pulumi.Input[str]] = None): + pulumi.set(__self__, "severity", severity) + if notifiers is not None: + pulumi.set(__self__, "notifiers", notifiers) + if repeat_interval is not None: + pulumi.set(__self__, "repeat_interval", repeat_interval) + + @property + @pulumi.getter + def severity(self) -> pulumi.Input[str]: + return pulumi.get(self, "severity") + + @severity.setter + def severity(self, value: pulumi.Input[str]): + pulumi.set(self, "severity", value) + + @property + @pulumi.getter + def notifiers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]: + return pulumi.get(self, "notifiers") + + @notifiers.setter + def notifiers(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]): + pulumi.set(self, "notifiers", value) + + @property + @pulumi.getter(name="repeatInterval") + def repeat_interval(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "repeat_interval") + + @repeat_interval.setter + def repeat_interval(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "repeat_interval", value) + + +@pulumi.input_type +class NotificationPolicyRuleArgs: + def __init__(__self__, *, + severity: pulumi.Input[str], + notifiers: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None, + repeat_interval: Optional[pulumi.Input[str]] = None): + pulumi.set(__self__, "severity", severity) + if notifiers is not None: + pulumi.set(__self__, "notifiers", notifiers) + if repeat_interval is not None: + pulumi.set(__self__, "repeat_interval", repeat_interval) + + @property + @pulumi.getter + def severity(self) -> pulumi.Input[str]: + return pulumi.get(self, "severity") + + @severity.setter + def severity(self, value: pulumi.Input[str]): + pulumi.set(self, "severity", value) + + @property + @pulumi.getter + def notifiers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]: + return pulumi.get(self, "notifiers") + + @notifiers.setter + def notifiers(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]): + pulumi.set(self, "notifiers", value) + + @property + @pulumi.getter(name="repeatInterval") + def repeat_interval(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "repeat_interval") + + @repeat_interval.setter + def repeat_interval(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "repeat_interval", value) + + +@pulumi.input_type +class OpsgenieAlertNotifierResponderArgs: + def __init__(__self__, *, + type: pulumi.Input[str], + id: Optional[pulumi.Input[str]] = None, + name: Optional[pulumi.Input[str]] = None, + username: Optional[pulumi.Input[str]] = None): + pulumi.set(__self__, "type", type) + if id is not None: + pulumi.set(__self__, "id", id) + if name is not None: + pulumi.set(__self__, "name", name) + if username is not None: + pulumi.set(__self__, "username", username) + + @property + @pulumi.getter + def type(self) -> pulumi.Input[str]: + return pulumi.get(self, "type") + + @type.setter + def type(self, value: pulumi.Input[str]): + pulumi.set(self, "type", value) + + @property + @pulumi.getter + def id(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "id") + + @id.setter + def id(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "id", value) + + @property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "name", value) + + @property + @pulumi.getter + def username(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "username") + + @username.setter + def username(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "username", value) + + +@pulumi.input_type +class PagerdutyAlertNotifierImageArgs: + def __init__(__self__, *, + src: pulumi.Input[str], + alt: Optional[pulumi.Input[str]] = None, + href: Optional[pulumi.Input[str]] = None): + pulumi.set(__self__, "src", src) + if alt is not None: + pulumi.set(__self__, "alt", alt) + if href is not None: + pulumi.set(__self__, "href", href) + + @property + @pulumi.getter + def src(self) -> pulumi.Input[str]: + return pulumi.get(self, "src") + + @src.setter + def src(self, value: pulumi.Input[str]): + pulumi.set(self, "src", value) + + @property + @pulumi.getter + def alt(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "alt") + + @alt.setter + def alt(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "alt", value) + + @property + @pulumi.getter + def href(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "href") + + @href.setter + def href(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "href", value) + + +@pulumi.input_type +class PagerdutyAlertNotifierLinkArgs: + def __init__(__self__, *, + href: pulumi.Input[str], + text: Optional[pulumi.Input[str]] = None): + pulumi.set(__self__, "href", href) + if text is not None: + pulumi.set(__self__, "text", text) + + @property + @pulumi.getter + def href(self) -> pulumi.Input[str]: + return pulumi.get(self, "href") + + @href.setter + def href(self, value: pulumi.Input[str]): + pulumi.set(self, "href", value) + + @property + @pulumi.getter + def text(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "text") + + @text.setter + def text(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "text", value) + + +@pulumi.input_type +class ResourcePoolsConfigDefaultPoolArgs: + def __init__(__self__, *, + allocation: pulumi.Input['ResourcePoolsConfigDefaultPoolAllocationArgs'], + priorities: Optional[pulumi.Input['ResourcePoolsConfigDefaultPoolPrioritiesArgs']] = None): + pulumi.set(__self__, "allocation", allocation) + if priorities is not None: + pulumi.set(__self__, "priorities", priorities) + + @property + @pulumi.getter + def allocation(self) -> pulumi.Input['ResourcePoolsConfigDefaultPoolAllocationArgs']: + return pulumi.get(self, "allocation") + + @allocation.setter + def allocation(self, value: pulumi.Input['ResourcePoolsConfigDefaultPoolAllocationArgs']): + pulumi.set(self, "allocation", value) + + @property + @pulumi.getter + def priorities(self) -> Optional[pulumi.Input['ResourcePoolsConfigDefaultPoolPrioritiesArgs']]: + return pulumi.get(self, "priorities") + + @priorities.setter + def priorities(self, value: Optional[pulumi.Input['ResourcePoolsConfigDefaultPoolPrioritiesArgs']]): + pulumi.set(self, "priorities", value) + + +@pulumi.input_type +class ResourcePoolsConfigDefaultPoolAllocationArgs: + def __init__(__self__, *, + percent_of_license: pulumi.Input[float]): + pulumi.set(__self__, "percent_of_license", percent_of_license) + + @property + @pulumi.getter(name="percentOfLicense") + def percent_of_license(self) -> pulumi.Input[float]: + return pulumi.get(self, "percent_of_license") + + @percent_of_license.setter + def percent_of_license(self, value: pulumi.Input[float]): + pulumi.set(self, "percent_of_license", value) + + +@pulumi.input_type +class ResourcePoolsConfigDefaultPoolPrioritiesArgs: + def __init__(__self__, *, + high_priority_match_rules: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None, + low_priority_match_rules: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None): + if high_priority_match_rules is not None: + pulumi.set(__self__, "high_priority_match_rules", high_priority_match_rules) + if low_priority_match_rules is not None: + pulumi.set(__self__, "low_priority_match_rules", low_priority_match_rules) + + @property + @pulumi.getter(name="highPriorityMatchRules") + def high_priority_match_rules(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]: + return pulumi.get(self, "high_priority_match_rules") + + @high_priority_match_rules.setter + def high_priority_match_rules(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]): + pulumi.set(self, "high_priority_match_rules", value) + + @property + @pulumi.getter(name="lowPriorityMatchRules") + def low_priority_match_rules(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]: + return pulumi.get(self, "low_priority_match_rules") + + @low_priority_match_rules.setter + def low_priority_match_rules(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]): + pulumi.set(self, "low_priority_match_rules", value) + + +@pulumi.input_type +class ResourcePoolsConfigPoolArgs: + def __init__(__self__, *, + allocation: pulumi.Input['ResourcePoolsConfigPoolAllocationArgs'], + name: pulumi.Input[str], + match_rule: Optional[pulumi.Input[str]] = None, + match_rules: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None, + priorities: Optional[pulumi.Input['ResourcePoolsConfigPoolPrioritiesArgs']] = None): + pulumi.set(__self__, "allocation", allocation) + pulumi.set(__self__, "name", name) + if match_rule is not None: + warnings.warn("""use match_rules""", DeprecationWarning) + pulumi.log.warn("""match_rule is deprecated: use match_rules""") + if match_rule is not None: + pulumi.set(__self__, "match_rule", match_rule) + if match_rules is not None: + pulumi.set(__self__, "match_rules", match_rules) + if priorities is not None: + pulumi.set(__self__, "priorities", priorities) + + @property + @pulumi.getter + def allocation(self) -> pulumi.Input['ResourcePoolsConfigPoolAllocationArgs']: + return pulumi.get(self, "allocation") + + @allocation.setter + def allocation(self, value: pulumi.Input['ResourcePoolsConfigPoolAllocationArgs']): + pulumi.set(self, "allocation", value) + + @property + @pulumi.getter + def name(self) -> pulumi.Input[str]: + return pulumi.get(self, "name") + + @name.setter + def name(self, value: pulumi.Input[str]): + pulumi.set(self, "name", value) + + @property + @pulumi.getter(name="matchRule") + def match_rule(self) -> Optional[pulumi.Input[str]]: + warnings.warn("""use match_rules""", DeprecationWarning) + pulumi.log.warn("""match_rule is deprecated: use match_rules""") + + return pulumi.get(self, "match_rule") + + @match_rule.setter + def match_rule(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "match_rule", value) + + @property + @pulumi.getter(name="matchRules") + def match_rules(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]: + return pulumi.get(self, "match_rules") + + @match_rules.setter + def match_rules(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]): + pulumi.set(self, "match_rules", value) + + @property + @pulumi.getter + def priorities(self) -> Optional[pulumi.Input['ResourcePoolsConfigPoolPrioritiesArgs']]: + return pulumi.get(self, "priorities") + + @priorities.setter + def priorities(self, value: Optional[pulumi.Input['ResourcePoolsConfigPoolPrioritiesArgs']]): + pulumi.set(self, "priorities", value) + + +@pulumi.input_type +class ResourcePoolsConfigPoolAllocationArgs: + def __init__(__self__, *, + percent_of_license: pulumi.Input[float]): + pulumi.set(__self__, "percent_of_license", percent_of_license) + + @property + @pulumi.getter(name="percentOfLicense") + def percent_of_license(self) -> pulumi.Input[float]: + return pulumi.get(self, "percent_of_license") + + @percent_of_license.setter + def percent_of_license(self, value: pulumi.Input[float]): + pulumi.set(self, "percent_of_license", value) + + +@pulumi.input_type +class ResourcePoolsConfigPoolPrioritiesArgs: + def __init__(__self__, *, + high_priority_match_rules: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None, + low_priority_match_rules: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None): + if high_priority_match_rules is not None: + pulumi.set(__self__, "high_priority_match_rules", high_priority_match_rules) + if low_priority_match_rules is not None: + pulumi.set(__self__, "low_priority_match_rules", low_priority_match_rules) + + @property + @pulumi.getter(name="highPriorityMatchRules") + def high_priority_match_rules(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]: + return pulumi.get(self, "high_priority_match_rules") + + @high_priority_match_rules.setter + def high_priority_match_rules(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]): + pulumi.set(self, "high_priority_match_rules", value) + + @property + @pulumi.getter(name="lowPriorityMatchRules") + def low_priority_match_rules(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]: + return pulumi.get(self, "low_priority_match_rules") + + @low_priority_match_rules.setter + def low_priority_match_rules(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]): + pulumi.set(self, "low_priority_match_rules", value) + + +@pulumi.input_type +class RollupRuleStoragePoliciesArgs: + def __init__(__self__, *, + resolution: pulumi.Input[str], + retention: pulumi.Input[str]): + pulumi.set(__self__, "resolution", resolution) + pulumi.set(__self__, "retention", retention) + + @property + @pulumi.getter + def resolution(self) -> pulumi.Input[str]: + return pulumi.get(self, "resolution") + + @resolution.setter + def resolution(self, value: pulumi.Input[str]): + pulumi.set(self, "resolution", value) + + @property + @pulumi.getter + def retention(self) -> pulumi.Input[str]: + return pulumi.get(self, "retention") + + @retention.setter + def retention(self, value: pulumi.Input[str]): + pulumi.set(self, "retention", value) + + +@pulumi.input_type +class ServiceAccountRestrictionArgs: + def __init__(__self__, *, + permission: pulumi.Input[str], + labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None): + pulumi.set(__self__, "permission", permission) + if labels is not None: + pulumi.set(__self__, "labels", labels) + + @property + @pulumi.getter + def permission(self) -> pulumi.Input[str]: + return pulumi.get(self, "permission") + + @permission.setter + def permission(self, value: pulumi.Input[str]): + pulumi.set(self, "permission", value) + + @property + @pulumi.getter + def labels(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]: + return pulumi.get(self, "labels") + + @labels.setter + def labels(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]): + pulumi.set(self, "labels", value) + + +@pulumi.input_type +class SlackAlertNotifierActionArgs: + def __init__(__self__, *, + action_confirm_dismiss_text: Optional[pulumi.Input[str]] = None, + action_confirm_ok_text: Optional[pulumi.Input[str]] = None, + action_confirm_text: Optional[pulumi.Input[str]] = None, + action_confirm_tile: Optional[pulumi.Input[str]] = None, + name: Optional[pulumi.Input[str]] = None, + style: Optional[pulumi.Input[str]] = None, + text: Optional[pulumi.Input[str]] = None, + type: Optional[pulumi.Input[str]] = None, + url: Optional[pulumi.Input[str]] = None, + value: Optional[pulumi.Input[str]] = None): + if action_confirm_dismiss_text is not None: + pulumi.set(__self__, "action_confirm_dismiss_text", action_confirm_dismiss_text) + if action_confirm_ok_text is not None: + pulumi.set(__self__, "action_confirm_ok_text", action_confirm_ok_text) + if action_confirm_text is not None: + pulumi.set(__self__, "action_confirm_text", action_confirm_text) + if action_confirm_tile is not None: + pulumi.set(__self__, "action_confirm_tile", action_confirm_tile) + if name is not None: + pulumi.set(__self__, "name", name) + if style is not None: + pulumi.set(__self__, "style", style) + if text is not None: + pulumi.set(__self__, "text", text) + if type is not None: + pulumi.set(__self__, "type", type) + if url is not None: + pulumi.set(__self__, "url", url) + if value is not None: + pulumi.set(__self__, "value", value) + + @property + @pulumi.getter(name="actionConfirmDismissText") + def action_confirm_dismiss_text(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "action_confirm_dismiss_text") + + @action_confirm_dismiss_text.setter + def action_confirm_dismiss_text(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "action_confirm_dismiss_text", value) + + @property + @pulumi.getter(name="actionConfirmOkText") + def action_confirm_ok_text(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "action_confirm_ok_text") + + @action_confirm_ok_text.setter + def action_confirm_ok_text(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "action_confirm_ok_text", value) + + @property + @pulumi.getter(name="actionConfirmText") + def action_confirm_text(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "action_confirm_text") + + @action_confirm_text.setter + def action_confirm_text(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "action_confirm_text", value) + + @property + @pulumi.getter(name="actionConfirmTile") + def action_confirm_tile(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "action_confirm_tile") + + @action_confirm_tile.setter + def action_confirm_tile(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "action_confirm_tile", value) + + @property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "name", value) + + @property + @pulumi.getter + def style(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "style") + + @style.setter + def style(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "style", value) + + @property + @pulumi.getter + def text(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "text") + + @text.setter + def text(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "text", value) + + @property + @pulumi.getter + def type(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "type") + + @type.setter + def type(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "type", value) + + @property + @pulumi.getter + def url(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "url") + + @url.setter + def url(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "url", value) + + @property + @pulumi.getter + def value(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "value") + + @value.setter + def value(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "value", value) + + +@pulumi.input_type +class SlackAlertNotifierFieldArgs: + def __init__(__self__, *, + short: Optional[pulumi.Input[bool]] = None, + title: Optional[pulumi.Input[str]] = None, + value: Optional[pulumi.Input[str]] = None): + if short is not None: + pulumi.set(__self__, "short", short) + if title is not None: + pulumi.set(__self__, "title", title) + if value is not None: + pulumi.set(__self__, "value", value) + + @property + @pulumi.getter + def short(self) -> Optional[pulumi.Input[bool]]: + return pulumi.get(self, "short") + + @short.setter + def short(self, value: Optional[pulumi.Input[bool]]): + pulumi.set(self, "short", value) + + @property + @pulumi.getter + def title(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "title") + + @title.setter + def title(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "title", value) + + @property + @pulumi.getter + def value(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "value") + + @value.setter + def value(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "value", value) + + +@pulumi.input_type +class TraceJaegerRemoteSamplingStrategyAppliedStrategyArgs: + def __init__(__self__, *, + per_operation_strategies: Optional[pulumi.Input['TraceJaegerRemoteSamplingStrategyAppliedStrategyPerOperationStrategiesArgs']] = None, + probabilistic_strategy: Optional[pulumi.Input['TraceJaegerRemoteSamplingStrategyAppliedStrategyProbabilisticStrategyArgs']] = None, + rate_limiting_strategy: Optional[pulumi.Input['TraceJaegerRemoteSamplingStrategyAppliedStrategyRateLimitingStrategyArgs']] = None): + if per_operation_strategies is not None: + pulumi.set(__self__, "per_operation_strategies", per_operation_strategies) + if probabilistic_strategy is not None: + pulumi.set(__self__, "probabilistic_strategy", probabilistic_strategy) + if rate_limiting_strategy is not None: + pulumi.set(__self__, "rate_limiting_strategy", rate_limiting_strategy) + + @property + @pulumi.getter(name="perOperationStrategies") + def per_operation_strategies(self) -> Optional[pulumi.Input['TraceJaegerRemoteSamplingStrategyAppliedStrategyPerOperationStrategiesArgs']]: + return pulumi.get(self, "per_operation_strategies") + + @per_operation_strategies.setter + def per_operation_strategies(self, value: Optional[pulumi.Input['TraceJaegerRemoteSamplingStrategyAppliedStrategyPerOperationStrategiesArgs']]): + pulumi.set(self, "per_operation_strategies", value) + + @property + @pulumi.getter(name="probabilisticStrategy") + def probabilistic_strategy(self) -> Optional[pulumi.Input['TraceJaegerRemoteSamplingStrategyAppliedStrategyProbabilisticStrategyArgs']]: + return pulumi.get(self, "probabilistic_strategy") + + @probabilistic_strategy.setter + def probabilistic_strategy(self, value: Optional[pulumi.Input['TraceJaegerRemoteSamplingStrategyAppliedStrategyProbabilisticStrategyArgs']]): + pulumi.set(self, "probabilistic_strategy", value) + + @property + @pulumi.getter(name="rateLimitingStrategy") + def rate_limiting_strategy(self) -> Optional[pulumi.Input['TraceJaegerRemoteSamplingStrategyAppliedStrategyRateLimitingStrategyArgs']]: + return pulumi.get(self, "rate_limiting_strategy") + + @rate_limiting_strategy.setter + def rate_limiting_strategy(self, value: Optional[pulumi.Input['TraceJaegerRemoteSamplingStrategyAppliedStrategyRateLimitingStrategyArgs']]): + pulumi.set(self, "rate_limiting_strategy", value) + + +@pulumi.input_type +class TraceJaegerRemoteSamplingStrategyAppliedStrategyPerOperationStrategiesArgs: + def __init__(__self__, *, + default_sampling_rate: pulumi.Input[float], + default_lower_bound_traces_per_second: Optional[pulumi.Input[float]] = None, + default_upper_bound_traces_per_second: Optional[pulumi.Input[float]] = None, + per_operation_strategies: Optional[pulumi.Input[Sequence[pulumi.Input['TraceJaegerRemoteSamplingStrategyAppliedStrategyPerOperationStrategiesPerOperationStrategyArgs']]]] = None): + pulumi.set(__self__, "default_sampling_rate", default_sampling_rate) + if default_lower_bound_traces_per_second is not None: + pulumi.set(__self__, "default_lower_bound_traces_per_second", default_lower_bound_traces_per_second) + if default_upper_bound_traces_per_second is not None: + pulumi.set(__self__, "default_upper_bound_traces_per_second", default_upper_bound_traces_per_second) + if per_operation_strategies is not None: + pulumi.set(__self__, "per_operation_strategies", per_operation_strategies) + + @property + @pulumi.getter(name="defaultSamplingRate") + def default_sampling_rate(self) -> pulumi.Input[float]: + return pulumi.get(self, "default_sampling_rate") + + @default_sampling_rate.setter + def default_sampling_rate(self, value: pulumi.Input[float]): + pulumi.set(self, "default_sampling_rate", value) + + @property + @pulumi.getter(name="defaultLowerBoundTracesPerSecond") + def default_lower_bound_traces_per_second(self) -> Optional[pulumi.Input[float]]: + return pulumi.get(self, "default_lower_bound_traces_per_second") + + @default_lower_bound_traces_per_second.setter + def default_lower_bound_traces_per_second(self, value: Optional[pulumi.Input[float]]): + pulumi.set(self, "default_lower_bound_traces_per_second", value) + + @property + @pulumi.getter(name="defaultUpperBoundTracesPerSecond") + def default_upper_bound_traces_per_second(self) -> Optional[pulumi.Input[float]]: + return pulumi.get(self, "default_upper_bound_traces_per_second") + + @default_upper_bound_traces_per_second.setter + def default_upper_bound_traces_per_second(self, value: Optional[pulumi.Input[float]]): + pulumi.set(self, "default_upper_bound_traces_per_second", value) + + @property + @pulumi.getter(name="perOperationStrategies") + def per_operation_strategies(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['TraceJaegerRemoteSamplingStrategyAppliedStrategyPerOperationStrategiesPerOperationStrategyArgs']]]]: + return pulumi.get(self, "per_operation_strategies") + + @per_operation_strategies.setter + def per_operation_strategies(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['TraceJaegerRemoteSamplingStrategyAppliedStrategyPerOperationStrategiesPerOperationStrategyArgs']]]]): + pulumi.set(self, "per_operation_strategies", value) + + +@pulumi.input_type +class TraceJaegerRemoteSamplingStrategyAppliedStrategyPerOperationStrategiesPerOperationStrategyArgs: + def __init__(__self__, *, + operation: pulumi.Input[str], + probabilistic_strategy: pulumi.Input['TraceJaegerRemoteSamplingStrategyAppliedStrategyPerOperationStrategiesPerOperationStrategyProbabilisticStrategyArgs']): + pulumi.set(__self__, "operation", operation) + pulumi.set(__self__, "probabilistic_strategy", probabilistic_strategy) + + @property + @pulumi.getter + def operation(self) -> pulumi.Input[str]: + return pulumi.get(self, "operation") + + @operation.setter + def operation(self, value: pulumi.Input[str]): + pulumi.set(self, "operation", value) + + @property + @pulumi.getter(name="probabilisticStrategy") + def probabilistic_strategy(self) -> pulumi.Input['TraceJaegerRemoteSamplingStrategyAppliedStrategyPerOperationStrategiesPerOperationStrategyProbabilisticStrategyArgs']: + return pulumi.get(self, "probabilistic_strategy") + + @probabilistic_strategy.setter + def probabilistic_strategy(self, value: pulumi.Input['TraceJaegerRemoteSamplingStrategyAppliedStrategyPerOperationStrategiesPerOperationStrategyProbabilisticStrategyArgs']): + pulumi.set(self, "probabilistic_strategy", value) + + +@pulumi.input_type +class TraceJaegerRemoteSamplingStrategyAppliedStrategyPerOperationStrategiesPerOperationStrategyProbabilisticStrategyArgs: + def __init__(__self__, *, + sampling_rate: pulumi.Input[float]): + pulumi.set(__self__, "sampling_rate", sampling_rate) + + @property + @pulumi.getter(name="samplingRate") + def sampling_rate(self) -> pulumi.Input[float]: + return pulumi.get(self, "sampling_rate") + + @sampling_rate.setter + def sampling_rate(self, value: pulumi.Input[float]): + pulumi.set(self, "sampling_rate", value) + + +@pulumi.input_type +class TraceJaegerRemoteSamplingStrategyAppliedStrategyProbabilisticStrategyArgs: + def __init__(__self__, *, + sampling_rate: pulumi.Input[float]): + pulumi.set(__self__, "sampling_rate", sampling_rate) + + @property + @pulumi.getter(name="samplingRate") + def sampling_rate(self) -> pulumi.Input[float]: + return pulumi.get(self, "sampling_rate") + + @sampling_rate.setter + def sampling_rate(self, value: pulumi.Input[float]): + pulumi.set(self, "sampling_rate", value) + + +@pulumi.input_type +class TraceJaegerRemoteSamplingStrategyAppliedStrategyRateLimitingStrategyArgs: + def __init__(__self__, *, + max_traces_per_second: pulumi.Input[int]): + pulumi.set(__self__, "max_traces_per_second", max_traces_per_second) + + @property + @pulumi.getter(name="maxTracesPerSecond") + def max_traces_per_second(self) -> pulumi.Input[int]: + return pulumi.get(self, "max_traces_per_second") + + @max_traces_per_second.setter + def max_traces_per_second(self, value: pulumi.Input[int]): + pulumi.set(self, "max_traces_per_second", value) + + +@pulumi.input_type +class TraceMetricsRuleGroupByArgs: + def __init__(__self__, *, + key: pulumi.Input['TraceMetricsRuleGroupByKeyArgs'], + label: pulumi.Input[str]): + pulumi.set(__self__, "key", key) + pulumi.set(__self__, "label", label) + + @property + @pulumi.getter + def key(self) -> pulumi.Input['TraceMetricsRuleGroupByKeyArgs']: + return pulumi.get(self, "key") + + @key.setter + def key(self, value: pulumi.Input['TraceMetricsRuleGroupByKeyArgs']): + pulumi.set(self, "key", value) + + @property + @pulumi.getter + def label(self) -> pulumi.Input[str]: + return pulumi.get(self, "label") + + @label.setter + def label(self, value: pulumi.Input[str]): + pulumi.set(self, "label", value) + + +@pulumi.input_type +class TraceMetricsRuleGroupByKeyArgs: + def __init__(__self__, *, + type: pulumi.Input[str], + named_key: Optional[pulumi.Input[str]] = None): + pulumi.set(__self__, "type", type) + if named_key is not None: + pulumi.set(__self__, "named_key", named_key) + + @property + @pulumi.getter + def type(self) -> pulumi.Input[str]: + return pulumi.get(self, "type") + + @type.setter + def type(self, value: pulumi.Input[str]): + pulumi.set(self, "type", value) + + @property + @pulumi.getter(name="namedKey") + def named_key(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "named_key") + + @named_key.setter + def named_key(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "named_key", value) + + +@pulumi.input_type +class TraceMetricsRuleTraceFilterArgs: + def __init__(__self__, *, + spans: Optional[pulumi.Input[Sequence[pulumi.Input['TraceMetricsRuleTraceFilterSpanArgs']]]] = None, + trace: Optional[pulumi.Input['TraceMetricsRuleTraceFilterTraceArgs']] = None): + if spans is not None: + pulumi.set(__self__, "spans", spans) + if trace is not None: + pulumi.set(__self__, "trace", trace) + + @property + @pulumi.getter + def spans(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['TraceMetricsRuleTraceFilterSpanArgs']]]]: + return pulumi.get(self, "spans") + + @spans.setter + def spans(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['TraceMetricsRuleTraceFilterSpanArgs']]]]): + pulumi.set(self, "spans", value) + + @property + @pulumi.getter + def trace(self) -> Optional[pulumi.Input['TraceMetricsRuleTraceFilterTraceArgs']]: + return pulumi.get(self, "trace") + + @trace.setter + def trace(self, value: Optional[pulumi.Input['TraceMetricsRuleTraceFilterTraceArgs']]): + pulumi.set(self, "trace", value) + + +@pulumi.input_type +class TraceMetricsRuleTraceFilterSpanArgs: + def __init__(__self__, *, + duration: Optional[pulumi.Input['TraceMetricsRuleTraceFilterSpanDurationArgs']] = None, + error: Optional[pulumi.Input['TraceMetricsRuleTraceFilterSpanErrorArgs']] = None, + match_type: Optional[pulumi.Input[str]] = None, + operation: Optional[pulumi.Input['TraceMetricsRuleTraceFilterSpanOperationArgs']] = None, + parent_operation: Optional[pulumi.Input['TraceMetricsRuleTraceFilterSpanParentOperationArgs']] = None, + parent_service: Optional[pulumi.Input['TraceMetricsRuleTraceFilterSpanParentServiceArgs']] = None, + service: Optional[pulumi.Input['TraceMetricsRuleTraceFilterSpanServiceArgs']] = None, + span_count: Optional[pulumi.Input['TraceMetricsRuleTraceFilterSpanSpanCountArgs']] = None, + tags: Optional[pulumi.Input[Sequence[pulumi.Input['TraceMetricsRuleTraceFilterSpanTagArgs']]]] = None): + if duration is not None: + pulumi.set(__self__, "duration", duration) + if error is not None: + pulumi.set(__self__, "error", error) + if match_type is not None: + pulumi.set(__self__, "match_type", match_type) + if operation is not None: + pulumi.set(__self__, "operation", operation) + if parent_operation is not None: + pulumi.set(__self__, "parent_operation", parent_operation) + if parent_service is not None: + pulumi.set(__self__, "parent_service", parent_service) + if service is not None: + pulumi.set(__self__, "service", service) + if span_count is not None: + pulumi.set(__self__, "span_count", span_count) + if tags is not None: + pulumi.set(__self__, "tags", tags) + + @property + @pulumi.getter + def duration(self) -> Optional[pulumi.Input['TraceMetricsRuleTraceFilterSpanDurationArgs']]: + return pulumi.get(self, "duration") + + @duration.setter + def duration(self, value: Optional[pulumi.Input['TraceMetricsRuleTraceFilterSpanDurationArgs']]): + pulumi.set(self, "duration", value) + + @property + @pulumi.getter + def error(self) -> Optional[pulumi.Input['TraceMetricsRuleTraceFilterSpanErrorArgs']]: + return pulumi.get(self, "error") + + @error.setter + def error(self, value: Optional[pulumi.Input['TraceMetricsRuleTraceFilterSpanErrorArgs']]): + pulumi.set(self, "error", value) + + @property + @pulumi.getter(name="matchType") + def match_type(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "match_type") + + @match_type.setter + def match_type(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "match_type", value) + + @property + @pulumi.getter + def operation(self) -> Optional[pulumi.Input['TraceMetricsRuleTraceFilterSpanOperationArgs']]: + return pulumi.get(self, "operation") + + @operation.setter + def operation(self, value: Optional[pulumi.Input['TraceMetricsRuleTraceFilterSpanOperationArgs']]): + pulumi.set(self, "operation", value) + + @property + @pulumi.getter(name="parentOperation") + def parent_operation(self) -> Optional[pulumi.Input['TraceMetricsRuleTraceFilterSpanParentOperationArgs']]: + return pulumi.get(self, "parent_operation") + + @parent_operation.setter + def parent_operation(self, value: Optional[pulumi.Input['TraceMetricsRuleTraceFilterSpanParentOperationArgs']]): + pulumi.set(self, "parent_operation", value) + + @property + @pulumi.getter(name="parentService") + def parent_service(self) -> Optional[pulumi.Input['TraceMetricsRuleTraceFilterSpanParentServiceArgs']]: + return pulumi.get(self, "parent_service") + + @parent_service.setter + def parent_service(self, value: Optional[pulumi.Input['TraceMetricsRuleTraceFilterSpanParentServiceArgs']]): + pulumi.set(self, "parent_service", value) + + @property + @pulumi.getter + def service(self) -> Optional[pulumi.Input['TraceMetricsRuleTraceFilterSpanServiceArgs']]: + return pulumi.get(self, "service") + + @service.setter + def service(self, value: Optional[pulumi.Input['TraceMetricsRuleTraceFilterSpanServiceArgs']]): + pulumi.set(self, "service", value) + + @property + @pulumi.getter(name="spanCount") + def span_count(self) -> Optional[pulumi.Input['TraceMetricsRuleTraceFilterSpanSpanCountArgs']]: + return pulumi.get(self, "span_count") + + @span_count.setter + def span_count(self, value: Optional[pulumi.Input['TraceMetricsRuleTraceFilterSpanSpanCountArgs']]): + pulumi.set(self, "span_count", value) + + @property + @pulumi.getter + def tags(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['TraceMetricsRuleTraceFilterSpanTagArgs']]]]: + return pulumi.get(self, "tags") + + @tags.setter + def tags(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['TraceMetricsRuleTraceFilterSpanTagArgs']]]]): + pulumi.set(self, "tags", value) + + +@pulumi.input_type +class TraceMetricsRuleTraceFilterSpanDurationArgs: + def __init__(__self__, *, + max_seconds: Optional[pulumi.Input[float]] = None, + min_seconds: Optional[pulumi.Input[float]] = None): + if max_seconds is not None: + pulumi.set(__self__, "max_seconds", max_seconds) + if min_seconds is not None: + pulumi.set(__self__, "min_seconds", min_seconds) + + @property + @pulumi.getter(name="maxSeconds") + def max_seconds(self) -> Optional[pulumi.Input[float]]: + return pulumi.get(self, "max_seconds") + + @max_seconds.setter + def max_seconds(self, value: Optional[pulumi.Input[float]]): + pulumi.set(self, "max_seconds", value) + + @property + @pulumi.getter(name="minSeconds") + def min_seconds(self) -> Optional[pulumi.Input[float]]: + return pulumi.get(self, "min_seconds") + + @min_seconds.setter + def min_seconds(self, value: Optional[pulumi.Input[float]]): + pulumi.set(self, "min_seconds", value) + + +@pulumi.input_type +class TraceMetricsRuleTraceFilterSpanErrorArgs: + def __init__(__self__, *, + value: pulumi.Input[bool]): + pulumi.set(__self__, "value", value) + + @property + @pulumi.getter + def value(self) -> pulumi.Input[bool]: + return pulumi.get(self, "value") + + @value.setter + def value(self, value: pulumi.Input[bool]): + pulumi.set(self, "value", value) + + +@pulumi.input_type +class TraceMetricsRuleTraceFilterSpanOperationArgs: + def __init__(__self__, *, + value: pulumi.Input[str], + match: Optional[pulumi.Input[str]] = None): + pulumi.set(__self__, "value", value) + if match is not None: + pulumi.set(__self__, "match", match) + + @property + @pulumi.getter + def value(self) -> pulumi.Input[str]: + return pulumi.get(self, "value") + + @value.setter + def value(self, value: pulumi.Input[str]): + pulumi.set(self, "value", value) + + @property + @pulumi.getter + def match(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "match") + + @match.setter + def match(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "match", value) + + +@pulumi.input_type +class TraceMetricsRuleTraceFilterSpanParentOperationArgs: + def __init__(__self__, *, + value: pulumi.Input[str], + match: Optional[pulumi.Input[str]] = None): + pulumi.set(__self__, "value", value) + if match is not None: + pulumi.set(__self__, "match", match) + + @property + @pulumi.getter + def value(self) -> pulumi.Input[str]: + return pulumi.get(self, "value") + + @value.setter + def value(self, value: pulumi.Input[str]): + pulumi.set(self, "value", value) + + @property + @pulumi.getter + def match(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "match") + + @match.setter + def match(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "match", value) + + +@pulumi.input_type +class TraceMetricsRuleTraceFilterSpanParentServiceArgs: + def __init__(__self__, *, + value: pulumi.Input[str], + match: Optional[pulumi.Input[str]] = None): + pulumi.set(__self__, "value", value) + if match is not None: + pulumi.set(__self__, "match", match) + + @property + @pulumi.getter + def value(self) -> pulumi.Input[str]: + return pulumi.get(self, "value") + + @value.setter + def value(self, value: pulumi.Input[str]): + pulumi.set(self, "value", value) + + @property + @pulumi.getter + def match(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "match") + + @match.setter + def match(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "match", value) + + +@pulumi.input_type +class TraceMetricsRuleTraceFilterSpanServiceArgs: + def __init__(__self__, *, + value: pulumi.Input[str], + match: Optional[pulumi.Input[str]] = None): + pulumi.set(__self__, "value", value) + if match is not None: + pulumi.set(__self__, "match", match) + + @property + @pulumi.getter + def value(self) -> pulumi.Input[str]: + return pulumi.get(self, "value") + + @value.setter + def value(self, value: pulumi.Input[str]): + pulumi.set(self, "value", value) + + @property + @pulumi.getter + def match(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "match") + + @match.setter + def match(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "match", value) + + +@pulumi.input_type +class TraceMetricsRuleTraceFilterSpanSpanCountArgs: + def __init__(__self__, *, + max: Optional[pulumi.Input[int]] = None, + min: Optional[pulumi.Input[int]] = None): + if max is not None: + pulumi.set(__self__, "max", max) + if min is not None: + pulumi.set(__self__, "min", min) + + @property + @pulumi.getter + def max(self) -> Optional[pulumi.Input[int]]: + return pulumi.get(self, "max") + + @max.setter + def max(self, value: Optional[pulumi.Input[int]]): + pulumi.set(self, "max", value) + + @property + @pulumi.getter + def min(self) -> Optional[pulumi.Input[int]]: + return pulumi.get(self, "min") + + @min.setter + def min(self, value: Optional[pulumi.Input[int]]): + pulumi.set(self, "min", value) + + +@pulumi.input_type +class TraceMetricsRuleTraceFilterSpanTagArgs: + def __init__(__self__, *, + key: pulumi.Input[str], + numeric_value: Optional[pulumi.Input['TraceMetricsRuleTraceFilterSpanTagNumericValueArgs']] = None, + value: Optional[pulumi.Input['TraceMetricsRuleTraceFilterSpanTagValueArgs']] = None): + pulumi.set(__self__, "key", key) + if numeric_value is not None: + pulumi.set(__self__, "numeric_value", numeric_value) + if value is not None: + pulumi.set(__self__, "value", value) + + @property + @pulumi.getter + def key(self) -> pulumi.Input[str]: + return pulumi.get(self, "key") + + @key.setter + def key(self, value: pulumi.Input[str]): + pulumi.set(self, "key", value) + + @property + @pulumi.getter(name="numericValue") + def numeric_value(self) -> Optional[pulumi.Input['TraceMetricsRuleTraceFilterSpanTagNumericValueArgs']]: + return pulumi.get(self, "numeric_value") + + @numeric_value.setter + def numeric_value(self, value: Optional[pulumi.Input['TraceMetricsRuleTraceFilterSpanTagNumericValueArgs']]): + pulumi.set(self, "numeric_value", value) + + @property + @pulumi.getter + def value(self) -> Optional[pulumi.Input['TraceMetricsRuleTraceFilterSpanTagValueArgs']]: + return pulumi.get(self, "value") + + @value.setter + def value(self, value: Optional[pulumi.Input['TraceMetricsRuleTraceFilterSpanTagValueArgs']]): + pulumi.set(self, "value", value) + + +@pulumi.input_type +class TraceMetricsRuleTraceFilterSpanTagNumericValueArgs: + def __init__(__self__, *, + comparison: pulumi.Input[str], + value: pulumi.Input[float]): + pulumi.set(__self__, "comparison", comparison) + pulumi.set(__self__, "value", value) + + @property + @pulumi.getter + def comparison(self) -> pulumi.Input[str]: + return pulumi.get(self, "comparison") + + @comparison.setter + def comparison(self, value: pulumi.Input[str]): + pulumi.set(self, "comparison", value) + + @property + @pulumi.getter + def value(self) -> pulumi.Input[float]: + return pulumi.get(self, "value") + + @value.setter + def value(self, value: pulumi.Input[float]): + pulumi.set(self, "value", value) + + +@pulumi.input_type +class TraceMetricsRuleTraceFilterSpanTagValueArgs: + def __init__(__self__, *, + value: pulumi.Input[str], + match: Optional[pulumi.Input[str]] = None): + pulumi.set(__self__, "value", value) + if match is not None: + pulumi.set(__self__, "match", match) + + @property + @pulumi.getter + def value(self) -> pulumi.Input[str]: + return pulumi.get(self, "value") + + @value.setter + def value(self, value: pulumi.Input[str]): + pulumi.set(self, "value", value) + + @property + @pulumi.getter + def match(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "match") + + @match.setter + def match(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "match", value) + + +@pulumi.input_type +class TraceMetricsRuleTraceFilterTraceArgs: + def __init__(__self__, *, + duration: Optional[pulumi.Input['TraceMetricsRuleTraceFilterTraceDurationArgs']] = None, + error: Optional[pulumi.Input['TraceMetricsRuleTraceFilterTraceErrorArgs']] = None): + if duration is not None: + pulumi.set(__self__, "duration", duration) + if error is not None: + pulumi.set(__self__, "error", error) + + @property + @pulumi.getter + def duration(self) -> Optional[pulumi.Input['TraceMetricsRuleTraceFilterTraceDurationArgs']]: + return pulumi.get(self, "duration") + + @duration.setter + def duration(self, value: Optional[pulumi.Input['TraceMetricsRuleTraceFilterTraceDurationArgs']]): + pulumi.set(self, "duration", value) + + @property + @pulumi.getter + def error(self) -> Optional[pulumi.Input['TraceMetricsRuleTraceFilterTraceErrorArgs']]: + return pulumi.get(self, "error") + + @error.setter + def error(self, value: Optional[pulumi.Input['TraceMetricsRuleTraceFilterTraceErrorArgs']]): + pulumi.set(self, "error", value) + + +@pulumi.input_type +class TraceMetricsRuleTraceFilterTraceDurationArgs: + def __init__(__self__, *, + max_seconds: Optional[pulumi.Input[float]] = None, + min_seconds: Optional[pulumi.Input[float]] = None): + if max_seconds is not None: + pulumi.set(__self__, "max_seconds", max_seconds) + if min_seconds is not None: + pulumi.set(__self__, "min_seconds", min_seconds) + + @property + @pulumi.getter(name="maxSeconds") + def max_seconds(self) -> Optional[pulumi.Input[float]]: + return pulumi.get(self, "max_seconds") + + @max_seconds.setter + def max_seconds(self, value: Optional[pulumi.Input[float]]): + pulumi.set(self, "max_seconds", value) + + @property + @pulumi.getter(name="minSeconds") + def min_seconds(self) -> Optional[pulumi.Input[float]]: + return pulumi.get(self, "min_seconds") + + @min_seconds.setter + def min_seconds(self, value: Optional[pulumi.Input[float]]): + pulumi.set(self, "min_seconds", value) + + +@pulumi.input_type +class TraceMetricsRuleTraceFilterTraceErrorArgs: + def __init__(__self__, *, + value: pulumi.Input[bool]): + pulumi.set(__self__, "value", value) + + @property + @pulumi.getter + def value(self) -> pulumi.Input[bool]: + return pulumi.get(self, "value") + + @value.setter + def value(self, value: pulumi.Input[bool]): + pulumi.set(self, "value", value) + + +@pulumi.input_type +class TraceTailSamplingRulesDefaultSampleRateArgs: + def __init__(__self__, *, + sample_rate: pulumi.Input[float], + enabled: Optional[pulumi.Input[bool]] = None): + pulumi.set(__self__, "sample_rate", sample_rate) + if enabled is not None: + pulumi.set(__self__, "enabled", enabled) + + @property + @pulumi.getter(name="sampleRate") + def sample_rate(self) -> pulumi.Input[float]: + return pulumi.get(self, "sample_rate") + + @sample_rate.setter + def sample_rate(self, value: pulumi.Input[float]): + pulumi.set(self, "sample_rate", value) + + @property + @pulumi.getter + def enabled(self) -> Optional[pulumi.Input[bool]]: + return pulumi.get(self, "enabled") + + @enabled.setter + def enabled(self, value: Optional[pulumi.Input[bool]]): + pulumi.set(self, "enabled", value) + + +@pulumi.input_type +class TraceTailSamplingRulesRuleArgs: + def __init__(__self__, *, + filter: pulumi.Input['TraceTailSamplingRulesRuleFilterArgs'], + sample_rate: pulumi.Input[float], + name: Optional[pulumi.Input[str]] = None, + system_name: Optional[pulumi.Input[str]] = None): + pulumi.set(__self__, "filter", filter) + pulumi.set(__self__, "sample_rate", sample_rate) + if name is not None: + pulumi.set(__self__, "name", name) + if system_name is not None: + pulumi.set(__self__, "system_name", system_name) + + @property + @pulumi.getter + def filter(self) -> pulumi.Input['TraceTailSamplingRulesRuleFilterArgs']: + return pulumi.get(self, "filter") + + @filter.setter + def filter(self, value: pulumi.Input['TraceTailSamplingRulesRuleFilterArgs']): + pulumi.set(self, "filter", value) + + @property + @pulumi.getter(name="sampleRate") + def sample_rate(self) -> pulumi.Input[float]: + return pulumi.get(self, "sample_rate") + + @sample_rate.setter + def sample_rate(self, value: pulumi.Input[float]): + pulumi.set(self, "sample_rate", value) + + @property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "name", value) + + @property + @pulumi.getter(name="systemName") + def system_name(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "system_name") + + @system_name.setter + def system_name(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "system_name", value) + + +@pulumi.input_type +class TraceTailSamplingRulesRuleFilterArgs: + def __init__(__self__, *, + spans: Optional[pulumi.Input[Sequence[pulumi.Input['TraceTailSamplingRulesRuleFilterSpanArgs']]]] = None, + trace: Optional[pulumi.Input['TraceTailSamplingRulesRuleFilterTraceArgs']] = None): + if spans is not None: + pulumi.set(__self__, "spans", spans) + if trace is not None: + pulumi.set(__self__, "trace", trace) + + @property + @pulumi.getter + def spans(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['TraceTailSamplingRulesRuleFilterSpanArgs']]]]: + return pulumi.get(self, "spans") + + @spans.setter + def spans(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['TraceTailSamplingRulesRuleFilterSpanArgs']]]]): + pulumi.set(self, "spans", value) + + @property + @pulumi.getter + def trace(self) -> Optional[pulumi.Input['TraceTailSamplingRulesRuleFilterTraceArgs']]: + return pulumi.get(self, "trace") + + @trace.setter + def trace(self, value: Optional[pulumi.Input['TraceTailSamplingRulesRuleFilterTraceArgs']]): + pulumi.set(self, "trace", value) + + +@pulumi.input_type +class TraceTailSamplingRulesRuleFilterSpanArgs: + def __init__(__self__, *, + duration: Optional[pulumi.Input['TraceTailSamplingRulesRuleFilterSpanDurationArgs']] = None, + error: Optional[pulumi.Input['TraceTailSamplingRulesRuleFilterSpanErrorArgs']] = None, + match_type: Optional[pulumi.Input[str]] = None, + operation: Optional[pulumi.Input['TraceTailSamplingRulesRuleFilterSpanOperationArgs']] = None, + parent_operation: Optional[pulumi.Input['TraceTailSamplingRulesRuleFilterSpanParentOperationArgs']] = None, + parent_service: Optional[pulumi.Input['TraceTailSamplingRulesRuleFilterSpanParentServiceArgs']] = None, + service: Optional[pulumi.Input['TraceTailSamplingRulesRuleFilterSpanServiceArgs']] = None, + span_count: Optional[pulumi.Input['TraceTailSamplingRulesRuleFilterSpanSpanCountArgs']] = None, + tags: Optional[pulumi.Input[Sequence[pulumi.Input['TraceTailSamplingRulesRuleFilterSpanTagArgs']]]] = None): + if duration is not None: + pulumi.set(__self__, "duration", duration) + if error is not None: + pulumi.set(__self__, "error", error) + if match_type is not None: + pulumi.set(__self__, "match_type", match_type) + if operation is not None: + pulumi.set(__self__, "operation", operation) + if parent_operation is not None: + pulumi.set(__self__, "parent_operation", parent_operation) + if parent_service is not None: + pulumi.set(__self__, "parent_service", parent_service) + if service is not None: + pulumi.set(__self__, "service", service) + if span_count is not None: + pulumi.set(__self__, "span_count", span_count) + if tags is not None: + pulumi.set(__self__, "tags", tags) + + @property + @pulumi.getter + def duration(self) -> Optional[pulumi.Input['TraceTailSamplingRulesRuleFilterSpanDurationArgs']]: + return pulumi.get(self, "duration") + + @duration.setter + def duration(self, value: Optional[pulumi.Input['TraceTailSamplingRulesRuleFilterSpanDurationArgs']]): + pulumi.set(self, "duration", value) + + @property + @pulumi.getter + def error(self) -> Optional[pulumi.Input['TraceTailSamplingRulesRuleFilterSpanErrorArgs']]: + return pulumi.get(self, "error") + + @error.setter + def error(self, value: Optional[pulumi.Input['TraceTailSamplingRulesRuleFilterSpanErrorArgs']]): + pulumi.set(self, "error", value) + + @property + @pulumi.getter(name="matchType") + def match_type(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "match_type") + + @match_type.setter + def match_type(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "match_type", value) + + @property + @pulumi.getter + def operation(self) -> Optional[pulumi.Input['TraceTailSamplingRulesRuleFilterSpanOperationArgs']]: + return pulumi.get(self, "operation") + + @operation.setter + def operation(self, value: Optional[pulumi.Input['TraceTailSamplingRulesRuleFilterSpanOperationArgs']]): + pulumi.set(self, "operation", value) + + @property + @pulumi.getter(name="parentOperation") + def parent_operation(self) -> Optional[pulumi.Input['TraceTailSamplingRulesRuleFilterSpanParentOperationArgs']]: + return pulumi.get(self, "parent_operation") + + @parent_operation.setter + def parent_operation(self, value: Optional[pulumi.Input['TraceTailSamplingRulesRuleFilterSpanParentOperationArgs']]): + pulumi.set(self, "parent_operation", value) + + @property + @pulumi.getter(name="parentService") + def parent_service(self) -> Optional[pulumi.Input['TraceTailSamplingRulesRuleFilterSpanParentServiceArgs']]: + return pulumi.get(self, "parent_service") + + @parent_service.setter + def parent_service(self, value: Optional[pulumi.Input['TraceTailSamplingRulesRuleFilterSpanParentServiceArgs']]): + pulumi.set(self, "parent_service", value) + + @property + @pulumi.getter + def service(self) -> Optional[pulumi.Input['TraceTailSamplingRulesRuleFilterSpanServiceArgs']]: + return pulumi.get(self, "service") + + @service.setter + def service(self, value: Optional[pulumi.Input['TraceTailSamplingRulesRuleFilterSpanServiceArgs']]): + pulumi.set(self, "service", value) + + @property + @pulumi.getter(name="spanCount") + def span_count(self) -> Optional[pulumi.Input['TraceTailSamplingRulesRuleFilterSpanSpanCountArgs']]: + return pulumi.get(self, "span_count") + + @span_count.setter + def span_count(self, value: Optional[pulumi.Input['TraceTailSamplingRulesRuleFilterSpanSpanCountArgs']]): + pulumi.set(self, "span_count", value) + + @property + @pulumi.getter + def tags(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['TraceTailSamplingRulesRuleFilterSpanTagArgs']]]]: + return pulumi.get(self, "tags") + + @tags.setter + def tags(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['TraceTailSamplingRulesRuleFilterSpanTagArgs']]]]): + pulumi.set(self, "tags", value) + + +@pulumi.input_type +class TraceTailSamplingRulesRuleFilterSpanDurationArgs: + def __init__(__self__, *, + max_secs: Optional[pulumi.Input[float]] = None, + min_secs: Optional[pulumi.Input[float]] = None): + if max_secs is not None: + pulumi.set(__self__, "max_secs", max_secs) + if min_secs is not None: + pulumi.set(__self__, "min_secs", min_secs) + + @property + @pulumi.getter(name="maxSecs") + def max_secs(self) -> Optional[pulumi.Input[float]]: + return pulumi.get(self, "max_secs") + + @max_secs.setter + def max_secs(self, value: Optional[pulumi.Input[float]]): + pulumi.set(self, "max_secs", value) + + @property + @pulumi.getter(name="minSecs") + def min_secs(self) -> Optional[pulumi.Input[float]]: + return pulumi.get(self, "min_secs") + + @min_secs.setter + def min_secs(self, value: Optional[pulumi.Input[float]]): + pulumi.set(self, "min_secs", value) + + +@pulumi.input_type +class TraceTailSamplingRulesRuleFilterSpanErrorArgs: + def __init__(__self__, *, + value: pulumi.Input[bool]): + pulumi.set(__self__, "value", value) + + @property + @pulumi.getter + def value(self) -> pulumi.Input[bool]: + return pulumi.get(self, "value") + + @value.setter + def value(self, value: pulumi.Input[bool]): + pulumi.set(self, "value", value) + + +@pulumi.input_type +class TraceTailSamplingRulesRuleFilterSpanOperationArgs: + def __init__(__self__, *, + value: pulumi.Input[str], + match: Optional[pulumi.Input[str]] = None): + pulumi.set(__self__, "value", value) + if match is not None: + pulumi.set(__self__, "match", match) + + @property + @pulumi.getter + def value(self) -> pulumi.Input[str]: + return pulumi.get(self, "value") + + @value.setter + def value(self, value: pulumi.Input[str]): + pulumi.set(self, "value", value) + + @property + @pulumi.getter + def match(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "match") + + @match.setter + def match(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "match", value) + + +@pulumi.input_type +class TraceTailSamplingRulesRuleFilterSpanParentOperationArgs: + def __init__(__self__, *, + value: pulumi.Input[str], + match: Optional[pulumi.Input[str]] = None): + pulumi.set(__self__, "value", value) + if match is not None: + pulumi.set(__self__, "match", match) + + @property + @pulumi.getter + def value(self) -> pulumi.Input[str]: + return pulumi.get(self, "value") + + @value.setter + def value(self, value: pulumi.Input[str]): + pulumi.set(self, "value", value) + + @property + @pulumi.getter + def match(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "match") + + @match.setter + def match(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "match", value) + + +@pulumi.input_type +class TraceTailSamplingRulesRuleFilterSpanParentServiceArgs: + def __init__(__self__, *, + value: pulumi.Input[str], + match: Optional[pulumi.Input[str]] = None): + pulumi.set(__self__, "value", value) + if match is not None: + pulumi.set(__self__, "match", match) + + @property + @pulumi.getter + def value(self) -> pulumi.Input[str]: + return pulumi.get(self, "value") + + @value.setter + def value(self, value: pulumi.Input[str]): + pulumi.set(self, "value", value) + + @property + @pulumi.getter + def match(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "match") + + @match.setter + def match(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "match", value) + + +@pulumi.input_type +class TraceTailSamplingRulesRuleFilterSpanServiceArgs: + def __init__(__self__, *, + value: pulumi.Input[str], + match: Optional[pulumi.Input[str]] = None): + pulumi.set(__self__, "value", value) + if match is not None: + pulumi.set(__self__, "match", match) + + @property + @pulumi.getter + def value(self) -> pulumi.Input[str]: + return pulumi.get(self, "value") + + @value.setter + def value(self, value: pulumi.Input[str]): + pulumi.set(self, "value", value) + + @property + @pulumi.getter + def match(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "match") + + @match.setter + def match(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "match", value) + + +@pulumi.input_type +class TraceTailSamplingRulesRuleFilterSpanSpanCountArgs: + def __init__(__self__, *, + max: Optional[pulumi.Input[int]] = None, + min: Optional[pulumi.Input[int]] = None): + if max is not None: + pulumi.set(__self__, "max", max) + if min is not None: + pulumi.set(__self__, "min", min) + + @property + @pulumi.getter + def max(self) -> Optional[pulumi.Input[int]]: + return pulumi.get(self, "max") + + @max.setter + def max(self, value: Optional[pulumi.Input[int]]): + pulumi.set(self, "max", value) + + @property + @pulumi.getter + def min(self) -> Optional[pulumi.Input[int]]: + return pulumi.get(self, "min") + + @min.setter + def min(self, value: Optional[pulumi.Input[int]]): + pulumi.set(self, "min", value) + + +@pulumi.input_type +class TraceTailSamplingRulesRuleFilterSpanTagArgs: + def __init__(__self__, *, + key: Optional[pulumi.Input[str]] = None, + numeric_value: Optional[pulumi.Input['TraceTailSamplingRulesRuleFilterSpanTagNumericValueArgs']] = None, + value: Optional[pulumi.Input['TraceTailSamplingRulesRuleFilterSpanTagValueArgs']] = None): + if key is not None: + pulumi.set(__self__, "key", key) + if numeric_value is not None: + pulumi.set(__self__, "numeric_value", numeric_value) + if value is not None: + pulumi.set(__self__, "value", value) + + @property + @pulumi.getter + def key(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "key") + + @key.setter + def key(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "key", value) + + @property + @pulumi.getter(name="numericValue") + def numeric_value(self) -> Optional[pulumi.Input['TraceTailSamplingRulesRuleFilterSpanTagNumericValueArgs']]: + return pulumi.get(self, "numeric_value") + + @numeric_value.setter + def numeric_value(self, value: Optional[pulumi.Input['TraceTailSamplingRulesRuleFilterSpanTagNumericValueArgs']]): + pulumi.set(self, "numeric_value", value) + + @property + @pulumi.getter + def value(self) -> Optional[pulumi.Input['TraceTailSamplingRulesRuleFilterSpanTagValueArgs']]: + return pulumi.get(self, "value") + + @value.setter + def value(self, value: Optional[pulumi.Input['TraceTailSamplingRulesRuleFilterSpanTagValueArgs']]): + pulumi.set(self, "value", value) + + +@pulumi.input_type +class TraceTailSamplingRulesRuleFilterSpanTagNumericValueArgs: + def __init__(__self__, *, + comparison: pulumi.Input[str], + value: pulumi.Input[float]): + pulumi.set(__self__, "comparison", comparison) + pulumi.set(__self__, "value", value) + + @property + @pulumi.getter + def comparison(self) -> pulumi.Input[str]: + return pulumi.get(self, "comparison") + + @comparison.setter + def comparison(self, value: pulumi.Input[str]): + pulumi.set(self, "comparison", value) + + @property + @pulumi.getter + def value(self) -> pulumi.Input[float]: + return pulumi.get(self, "value") + + @value.setter + def value(self, value: pulumi.Input[float]): + pulumi.set(self, "value", value) + + +@pulumi.input_type +class TraceTailSamplingRulesRuleFilterSpanTagValueArgs: + def __init__(__self__, *, + value: pulumi.Input[str], + match: Optional[pulumi.Input[str]] = None): + pulumi.set(__self__, "value", value) + if match is not None: + pulumi.set(__self__, "match", match) + + @property + @pulumi.getter + def value(self) -> pulumi.Input[str]: + return pulumi.get(self, "value") + + @value.setter + def value(self, value: pulumi.Input[str]): + pulumi.set(self, "value", value) + + @property + @pulumi.getter + def match(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "match") + + @match.setter + def match(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "match", value) + + +@pulumi.input_type +class TraceTailSamplingRulesRuleFilterTraceArgs: + def __init__(__self__, *, + duration: Optional[pulumi.Input['TraceTailSamplingRulesRuleFilterTraceDurationArgs']] = None, + error: Optional[pulumi.Input['TraceTailSamplingRulesRuleFilterTraceErrorArgs']] = None): + if duration is not None: + pulumi.set(__self__, "duration", duration) + if error is not None: + pulumi.set(__self__, "error", error) + + @property + @pulumi.getter + def duration(self) -> Optional[pulumi.Input['TraceTailSamplingRulesRuleFilterTraceDurationArgs']]: + return pulumi.get(self, "duration") + + @duration.setter + def duration(self, value: Optional[pulumi.Input['TraceTailSamplingRulesRuleFilterTraceDurationArgs']]): + pulumi.set(self, "duration", value) + + @property + @pulumi.getter + def error(self) -> Optional[pulumi.Input['TraceTailSamplingRulesRuleFilterTraceErrorArgs']]: + return pulumi.get(self, "error") + + @error.setter + def error(self, value: Optional[pulumi.Input['TraceTailSamplingRulesRuleFilterTraceErrorArgs']]): + pulumi.set(self, "error", value) + + +@pulumi.input_type +class TraceTailSamplingRulesRuleFilterTraceDurationArgs: + def __init__(__self__, *, + max_secs: Optional[pulumi.Input[float]] = None, + min_secs: Optional[pulumi.Input[float]] = None): + if max_secs is not None: + pulumi.set(__self__, "max_secs", max_secs) + if min_secs is not None: + pulumi.set(__self__, "min_secs", min_secs) + + @property + @pulumi.getter(name="maxSecs") + def max_secs(self) -> Optional[pulumi.Input[float]]: + return pulumi.get(self, "max_secs") + + @max_secs.setter + def max_secs(self, value: Optional[pulumi.Input[float]]): + pulumi.set(self, "max_secs", value) + + @property + @pulumi.getter(name="minSecs") + def min_secs(self) -> Optional[pulumi.Input[float]]: + return pulumi.get(self, "min_secs") + + @min_secs.setter + def min_secs(self, value: Optional[pulumi.Input[float]]): + pulumi.set(self, "min_secs", value) + + +@pulumi.input_type +class TraceTailSamplingRulesRuleFilterTraceErrorArgs: + def __init__(__self__, *, + value: pulumi.Input[bool]): + pulumi.set(__self__, "value", value) + + @property + @pulumi.getter + def value(self) -> pulumi.Input[bool]: + return pulumi.get(self, "value") + + @value.setter + def value(self, value: pulumi.Input[bool]): + pulumi.set(self, "value", value) + + diff --git a/sdk/python/chronosphereio_chronosphere/_utilities.py b/sdk/python/chronosphereio_chronosphere/_utilities.py new file mode 100644 index 00000000..2d9a3c84 --- /dev/null +++ b/sdk/python/chronosphereio_chronosphere/_utilities.py @@ -0,0 +1,250 @@ +# coding=utf-8 +# *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + + +import importlib.util +import inspect +import json +import os +import pkg_resources +import sys +import typing + +import pulumi +import pulumi.runtime + +from semver import VersionInfo as SemverVersion +from parver import Version as PEP440Version + + +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 = pkg_resources.require(root_package)[0].version + 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: + prerelease = f"dev.{pep440_version.dev}" + + # The only significant difference between PEP440 and semver as it pertains to us is that PEP440 has explicit support + # for dev builds, while semver encodes them as "prerelease" versions. In order 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. + 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_version(): + return _version_str + +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 get_plugin_download_url(): + return None diff --git a/sdk/python/chronosphereio_chronosphere/blackhole_alert_notifier.py b/sdk/python/chronosphereio_chronosphere/blackhole_alert_notifier.py new file mode 100644 index 00000000..17e38e9c --- /dev/null +++ b/sdk/python/chronosphereio_chronosphere/blackhole_alert_notifier.py @@ -0,0 +1,165 @@ +# coding=utf-8 +# *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import copy +import warnings +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +from . import _utilities + +__all__ = ['BlackholeAlertNotifierArgs', 'BlackholeAlertNotifier'] + +@pulumi.input_type +class BlackholeAlertNotifierArgs: + def __init__(__self__, *, + name: pulumi.Input[str], + slug: Optional[pulumi.Input[str]] = None): + """ + The set of arguments for constructing a BlackholeAlertNotifier resource. + """ + pulumi.set(__self__, "name", name) + if slug is not None: + pulumi.set(__self__, "slug", slug) + + @property + @pulumi.getter + def name(self) -> pulumi.Input[str]: + return pulumi.get(self, "name") + + @name.setter + def name(self, value: pulumi.Input[str]): + pulumi.set(self, "name", value) + + @property + @pulumi.getter + def slug(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "slug") + + @slug.setter + def slug(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "slug", value) + + +@pulumi.input_type +class _BlackholeAlertNotifierState: + def __init__(__self__, *, + name: Optional[pulumi.Input[str]] = None, + slug: Optional[pulumi.Input[str]] = None): + """ + Input properties used for looking up and filtering BlackholeAlertNotifier resources. + """ + if name is not None: + pulumi.set(__self__, "name", name) + if slug is not None: + pulumi.set(__self__, "slug", slug) + + @property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "name", value) + + @property + @pulumi.getter + def slug(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "slug") + + @slug.setter + def slug(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "slug", value) + + +class BlackholeAlertNotifier(pulumi.CustomResource): + @overload + def __init__(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + name: Optional[pulumi.Input[str]] = None, + slug: Optional[pulumi.Input[str]] = None, + __props__=None): + """ + Create a BlackholeAlertNotifier resource with the given unique name, props, and options. + :param str resource_name: The name of the resource. + :param pulumi.ResourceOptions opts: Options for the resource. + """ + ... + @overload + def __init__(__self__, + resource_name: str, + args: BlackholeAlertNotifierArgs, + opts: Optional[pulumi.ResourceOptions] = None): + """ + Create a BlackholeAlertNotifier resource with the given unique name, props, and options. + :param str resource_name: The name of the resource. + :param BlackholeAlertNotifierArgs 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(BlackholeAlertNotifierArgs, 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[str]] = None, + slug: Optional[pulumi.Input[str]] = None, + __props__=None): + opts = pulumi.ResourceOptions.merge(_utilities.get_resource_opts_defaults(), opts) + if not isinstance(opts, pulumi.ResourceOptions): + raise TypeError('Expected resource options to be a ResourceOptions instance') + if opts.id is None: + if __props__ is not None: + raise TypeError('__props__ is only valid when passed in combination with a valid opts.id to get an existing resource') + __props__ = BlackholeAlertNotifierArgs.__new__(BlackholeAlertNotifierArgs) + + if name is None and not opts.urn: + raise TypeError("Missing required property 'name'") + __props__.__dict__["name"] = name + __props__.__dict__["slug"] = slug + super(BlackholeAlertNotifier, __self__).__init__( + 'chronosphere:index/blackholeAlertNotifier:BlackholeAlertNotifier', + resource_name, + __props__, + opts) + + @staticmethod + def get(resource_name: str, + id: pulumi.Input[str], + opts: Optional[pulumi.ResourceOptions] = None, + name: Optional[pulumi.Input[str]] = None, + slug: Optional[pulumi.Input[str]] = None) -> 'BlackholeAlertNotifier': + """ + Get an existing BlackholeAlertNotifier 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. + """ + opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id)) + + __props__ = _BlackholeAlertNotifierState.__new__(_BlackholeAlertNotifierState) + + __props__.__dict__["name"] = name + __props__.__dict__["slug"] = slug + return BlackholeAlertNotifier(resource_name, opts=opts, __props__=__props__) + + @property + @pulumi.getter + def name(self) -> pulumi.Output[str]: + return pulumi.get(self, "name") + + @property + @pulumi.getter + def slug(self) -> pulumi.Output[str]: + return pulumi.get(self, "slug") + diff --git a/sdk/python/chronosphereio_chronosphere/bucket.py b/sdk/python/chronosphereio_chronosphere/bucket.py new file mode 100644 index 00000000..528fd195 --- /dev/null +++ b/sdk/python/chronosphereio_chronosphere/bucket.py @@ -0,0 +1,355 @@ +# coding=utf-8 +# *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import copy +import warnings +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +from . import _utilities + +__all__ = ['BucketArgs', 'Bucket'] + +@pulumi.input_type +class BucketArgs: + def __init__(__self__, *, + name: pulumi.Input[str], + description: Optional[pulumi.Input[str]] = None, + labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None, + notification_policy_data: Optional[pulumi.Input[str]] = None, + notification_policy_id: Optional[pulumi.Input[str]] = None, + slug: Optional[pulumi.Input[str]] = None, + team_id: Optional[pulumi.Input[str]] = None): + """ + The set of arguments for constructing a Bucket resource. + """ + pulumi.set(__self__, "name", name) + if description is not None: + pulumi.set(__self__, "description", description) + if labels is not None: + pulumi.set(__self__, "labels", labels) + if notification_policy_data is not None: + pulumi.set(__self__, "notification_policy_data", notification_policy_data) + if notification_policy_id is not None: + pulumi.set(__self__, "notification_policy_id", notification_policy_id) + if slug is not None: + pulumi.set(__self__, "slug", slug) + if team_id is not None: + pulumi.set(__self__, "team_id", team_id) + + @property + @pulumi.getter + def name(self) -> pulumi.Input[str]: + return pulumi.get(self, "name") + + @name.setter + def name(self, value: pulumi.Input[str]): + pulumi.set(self, "name", value) + + @property + @pulumi.getter + def description(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "description") + + @description.setter + def description(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "description", value) + + @property + @pulumi.getter + def labels(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]: + return pulumi.get(self, "labels") + + @labels.setter + def labels(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]): + pulumi.set(self, "labels", value) + + @property + @pulumi.getter(name="notificationPolicyData") + def notification_policy_data(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "notification_policy_data") + + @notification_policy_data.setter + def notification_policy_data(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "notification_policy_data", value) + + @property + @pulumi.getter(name="notificationPolicyId") + def notification_policy_id(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "notification_policy_id") + + @notification_policy_id.setter + def notification_policy_id(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "notification_policy_id", value) + + @property + @pulumi.getter + def slug(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "slug") + + @slug.setter + def slug(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "slug", value) + + @property + @pulumi.getter(name="teamId") + def team_id(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "team_id") + + @team_id.setter + def team_id(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "team_id", value) + + +@pulumi.input_type +class _BucketState: + def __init__(__self__, *, + description: Optional[pulumi.Input[str]] = None, + labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None, + name: Optional[pulumi.Input[str]] = None, + notification_policy_data: Optional[pulumi.Input[str]] = None, + notification_policy_id: Optional[pulumi.Input[str]] = None, + notification_policy_slug: Optional[pulumi.Input[str]] = None, + slug: Optional[pulumi.Input[str]] = None, + team_id: Optional[pulumi.Input[str]] = None): + """ + Input properties used for looking up and filtering Bucket resources. + """ + 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 notification_policy_data is not None: + pulumi.set(__self__, "notification_policy_data", notification_policy_data) + if notification_policy_id is not None: + pulumi.set(__self__, "notification_policy_id", notification_policy_id) + if notification_policy_slug is not None: + pulumi.set(__self__, "notification_policy_slug", notification_policy_slug) + if slug is not None: + pulumi.set(__self__, "slug", slug) + if team_id is not None: + pulumi.set(__self__, "team_id", team_id) + + @property + @pulumi.getter + def description(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "description") + + @description.setter + def description(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "description", value) + + @property + @pulumi.getter + def labels(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]: + return pulumi.get(self, "labels") + + @labels.setter + def labels(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]): + pulumi.set(self, "labels", value) + + @property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "name", value) + + @property + @pulumi.getter(name="notificationPolicyData") + def notification_policy_data(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "notification_policy_data") + + @notification_policy_data.setter + def notification_policy_data(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "notification_policy_data", value) + + @property + @pulumi.getter(name="notificationPolicyId") + def notification_policy_id(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "notification_policy_id") + + @notification_policy_id.setter + def notification_policy_id(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "notification_policy_id", value) + + @property + @pulumi.getter(name="notificationPolicySlug") + def notification_policy_slug(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "notification_policy_slug") + + @notification_policy_slug.setter + def notification_policy_slug(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "notification_policy_slug", value) + + @property + @pulumi.getter + def slug(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "slug") + + @slug.setter + def slug(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "slug", value) + + @property + @pulumi.getter(name="teamId") + def team_id(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "team_id") + + @team_id.setter + def team_id(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "team_id", value) + + +class Bucket(pulumi.CustomResource): + @overload + def __init__(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + description: Optional[pulumi.Input[str]] = None, + labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None, + name: Optional[pulumi.Input[str]] = None, + notification_policy_data: Optional[pulumi.Input[str]] = None, + notification_policy_id: Optional[pulumi.Input[str]] = None, + slug: Optional[pulumi.Input[str]] = None, + team_id: Optional[pulumi.Input[str]] = None, + __props__=None): + """ + Create a Bucket resource with the given unique name, props, and options. + :param str resource_name: The name of the resource. + :param pulumi.ResourceOptions opts: Options for the resource. + """ + ... + @overload + def __init__(__self__, + resource_name: str, + args: BucketArgs, + opts: Optional[pulumi.ResourceOptions] = None): + """ + Create a Bucket resource with the given unique name, props, and options. + :param str resource_name: The name of the resource. + :param BucketArgs 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(BucketArgs, 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[str]] = None, + labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None, + name: Optional[pulumi.Input[str]] = None, + notification_policy_data: Optional[pulumi.Input[str]] = None, + notification_policy_id: Optional[pulumi.Input[str]] = None, + slug: Optional[pulumi.Input[str]] = None, + team_id: Optional[pulumi.Input[str]] = None, + __props__=None): + opts = pulumi.ResourceOptions.merge(_utilities.get_resource_opts_defaults(), opts) + if not isinstance(opts, pulumi.ResourceOptions): + raise TypeError('Expected resource options to be a ResourceOptions instance') + if opts.id is None: + if __props__ is not None: + raise TypeError('__props__ is only valid when passed in combination with a valid opts.id to get an existing resource') + __props__ = BucketArgs.__new__(BucketArgs) + + __props__.__dict__["description"] = description + __props__.__dict__["labels"] = labels + if name is None and not opts.urn: + raise TypeError("Missing required property 'name'") + __props__.__dict__["name"] = name + __props__.__dict__["notification_policy_data"] = notification_policy_data + __props__.__dict__["notification_policy_id"] = notification_policy_id + __props__.__dict__["slug"] = slug + __props__.__dict__["team_id"] = team_id + __props__.__dict__["notification_policy_slug"] = None + super(Bucket, __self__).__init__( + 'chronosphere:index/bucket:Bucket', + resource_name, + __props__, + opts) + + @staticmethod + def get(resource_name: str, + id: pulumi.Input[str], + opts: Optional[pulumi.ResourceOptions] = None, + description: Optional[pulumi.Input[str]] = None, + labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None, + name: Optional[pulumi.Input[str]] = None, + notification_policy_data: Optional[pulumi.Input[str]] = None, + notification_policy_id: Optional[pulumi.Input[str]] = None, + notification_policy_slug: Optional[pulumi.Input[str]] = None, + slug: Optional[pulumi.Input[str]] = None, + team_id: Optional[pulumi.Input[str]] = None) -> 'Bucket': + """ + Get an existing Bucket 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. + """ + opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id)) + + __props__ = _BucketState.__new__(_BucketState) + + __props__.__dict__["description"] = description + __props__.__dict__["labels"] = labels + __props__.__dict__["name"] = name + __props__.__dict__["notification_policy_data"] = notification_policy_data + __props__.__dict__["notification_policy_id"] = notification_policy_id + __props__.__dict__["notification_policy_slug"] = notification_policy_slug + __props__.__dict__["slug"] = slug + __props__.__dict__["team_id"] = team_id + return Bucket(resource_name, opts=opts, __props__=__props__) + + @property + @pulumi.getter + def description(self) -> pulumi.Output[Optional[str]]: + return pulumi.get(self, "description") + + @property + @pulumi.getter + def labels(self) -> pulumi.Output[Optional[Mapping[str, str]]]: + return pulumi.get(self, "labels") + + @property + @pulumi.getter + def name(self) -> pulumi.Output[str]: + return pulumi.get(self, "name") + + @property + @pulumi.getter(name="notificationPolicyData") + def notification_policy_data(self) -> pulumi.Output[Optional[str]]: + return pulumi.get(self, "notification_policy_data") + + @property + @pulumi.getter(name="notificationPolicyId") + def notification_policy_id(self) -> pulumi.Output[Optional[str]]: + return pulumi.get(self, "notification_policy_id") + + @property + @pulumi.getter(name="notificationPolicySlug") + def notification_policy_slug(self) -> pulumi.Output[str]: + return pulumi.get(self, "notification_policy_slug") + + @property + @pulumi.getter + def slug(self) -> pulumi.Output[str]: + return pulumi.get(self, "slug") + + @property + @pulumi.getter(name="teamId") + def team_id(self) -> pulumi.Output[Optional[str]]: + return pulumi.get(self, "team_id") + diff --git a/sdk/python/chronosphereio_chronosphere/bucket_data_source.py b/sdk/python/chronosphereio_chronosphere/bucket_data_source.py new file mode 100644 index 00000000..7fd8b167 --- /dev/null +++ b/sdk/python/chronosphereio_chronosphere/bucket_data_source.py @@ -0,0 +1,113 @@ +# coding=utf-8 +# *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import copy +import warnings +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +from . import _utilities + +__all__ = [ + 'BucketDataSourceResult', + 'AwaitableBucketDataSourceResult', + 'bucket_data_source', + 'bucket_data_source_output', +] + +@pulumi.output_type +class BucketDataSourceResult: + """ + A collection of values returned by BucketDataSource. + """ + def __init__(__self__, description=None, id=None, labels=None, name=None, slug=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 slug and not isinstance(slug, str): + raise TypeError("Expected argument 'slug' to be a str") + pulumi.set(__self__, "slug", slug) + + @property + @pulumi.getter + def description(self) -> str: + return pulumi.get(self, "description") + + @property + @pulumi.getter + def id(self) -> str: + """ + The provider-assigned unique ID for this managed resource. + """ + return pulumi.get(self, "id") + + @property + @pulumi.getter + def labels(self) -> Optional[Mapping[str, str]]: + return pulumi.get(self, "labels") + + @property + @pulumi.getter + def name(self) -> Optional[str]: + return pulumi.get(self, "name") + + @property + @pulumi.getter + def slug(self) -> Optional[str]: + return pulumi.get(self, "slug") + + +class AwaitableBucketDataSourceResult(BucketDataSourceResult): + # pylint: disable=using-constant-test + def __await__(self): + if False: + yield self + return BucketDataSourceResult( + description=self.description, + id=self.id, + labels=self.labels, + name=self.name, + slug=self.slug) + + +def bucket_data_source(labels: Optional[Mapping[str, str]] = None, + name: Optional[str] = None, + slug: Optional[str] = None, + opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableBucketDataSourceResult: + """ + Use this data source to access information about an existing resource. + """ + __args__ = dict() + __args__['labels'] = labels + __args__['name'] = name + __args__['slug'] = slug + opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke('chronosphere:index/bucketDataSource:BucketDataSource', __args__, opts=opts, typ=BucketDataSourceResult).value + + return AwaitableBucketDataSourceResult( + description=pulumi.get(__ret__, 'description'), + id=pulumi.get(__ret__, 'id'), + labels=pulumi.get(__ret__, 'labels'), + name=pulumi.get(__ret__, 'name'), + slug=pulumi.get(__ret__, 'slug')) + + +@_utilities.lift_output_func(bucket_data_source) +def bucket_data_source_output(labels: Optional[pulumi.Input[Optional[Mapping[str, str]]]] = None, + name: Optional[pulumi.Input[Optional[str]]] = None, + slug: Optional[pulumi.Input[Optional[str]]] = None, + opts: Optional[pulumi.InvokeOptions] = None) -> pulumi.Output[BucketDataSourceResult]: + """ + Use this data source to access information about an existing resource. + """ + ... diff --git a/sdk/python/chronosphereio_chronosphere/classic_dashboard.py b/sdk/python/chronosphereio_chronosphere/classic_dashboard.py new file mode 100644 index 00000000..ce615857 --- /dev/null +++ b/sdk/python/chronosphereio_chronosphere/classic_dashboard.py @@ -0,0 +1,199 @@ +# coding=utf-8 +# *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import copy +import warnings +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +from . import _utilities + +__all__ = ['ClassicDashboardArgs', 'ClassicDashboard'] + +@pulumi.input_type +class ClassicDashboardArgs: + def __init__(__self__, *, + dashboard_json: pulumi.Input[str], + bucket_id: Optional[pulumi.Input[str]] = None, + collection_id: Optional[pulumi.Input[str]] = None): + """ + The set of arguments for constructing a ClassicDashboard resource. + """ + pulumi.set(__self__, "dashboard_json", dashboard_json) + if bucket_id is not None: + pulumi.set(__self__, "bucket_id", bucket_id) + if collection_id is not None: + pulumi.set(__self__, "collection_id", collection_id) + + @property + @pulumi.getter(name="dashboardJson") + def dashboard_json(self) -> pulumi.Input[str]: + return pulumi.get(self, "dashboard_json") + + @dashboard_json.setter + def dashboard_json(self, value: pulumi.Input[str]): + pulumi.set(self, "dashboard_json", value) + + @property + @pulumi.getter(name="bucketId") + def bucket_id(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "bucket_id") + + @bucket_id.setter + def bucket_id(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "bucket_id", value) + + @property + @pulumi.getter(name="collectionId") + def collection_id(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "collection_id") + + @collection_id.setter + def collection_id(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "collection_id", value) + + +@pulumi.input_type +class _ClassicDashboardState: + def __init__(__self__, *, + bucket_id: Optional[pulumi.Input[str]] = None, + collection_id: Optional[pulumi.Input[str]] = None, + dashboard_json: Optional[pulumi.Input[str]] = None): + """ + Input properties used for looking up and filtering ClassicDashboard resources. + """ + if bucket_id is not None: + pulumi.set(__self__, "bucket_id", bucket_id) + if collection_id is not None: + pulumi.set(__self__, "collection_id", collection_id) + if dashboard_json is not None: + pulumi.set(__self__, "dashboard_json", dashboard_json) + + @property + @pulumi.getter(name="bucketId") + def bucket_id(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "bucket_id") + + @bucket_id.setter + def bucket_id(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "bucket_id", value) + + @property + @pulumi.getter(name="collectionId") + def collection_id(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "collection_id") + + @collection_id.setter + def collection_id(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "collection_id", value) + + @property + @pulumi.getter(name="dashboardJson") + def dashboard_json(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "dashboard_json") + + @dashboard_json.setter + def dashboard_json(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "dashboard_json", value) + + +class ClassicDashboard(pulumi.CustomResource): + @overload + def __init__(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + bucket_id: Optional[pulumi.Input[str]] = None, + collection_id: Optional[pulumi.Input[str]] = None, + dashboard_json: Optional[pulumi.Input[str]] = None, + __props__=None): + """ + Create a ClassicDashboard resource with the given unique name, props, and options. + :param str resource_name: The name of the resource. + :param pulumi.ResourceOptions opts: Options for the resource. + """ + ... + @overload + def __init__(__self__, + resource_name: str, + args: ClassicDashboardArgs, + opts: Optional[pulumi.ResourceOptions] = None): + """ + Create a ClassicDashboard resource with the given unique name, props, and options. + :param str resource_name: The name of the resource. + :param ClassicDashboardArgs 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(ClassicDashboardArgs, 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, + bucket_id: Optional[pulumi.Input[str]] = None, + collection_id: Optional[pulumi.Input[str]] = None, + dashboard_json: Optional[pulumi.Input[str]] = None, + __props__=None): + opts = pulumi.ResourceOptions.merge(_utilities.get_resource_opts_defaults(), opts) + if not isinstance(opts, pulumi.ResourceOptions): + raise TypeError('Expected resource options to be a ResourceOptions instance') + if opts.id is None: + if __props__ is not None: + raise TypeError('__props__ is only valid when passed in combination with a valid opts.id to get an existing resource') + __props__ = ClassicDashboardArgs.__new__(ClassicDashboardArgs) + + __props__.__dict__["bucket_id"] = bucket_id + __props__.__dict__["collection_id"] = collection_id + if dashboard_json is None and not opts.urn: + raise TypeError("Missing required property 'dashboard_json'") + __props__.__dict__["dashboard_json"] = dashboard_json + super(ClassicDashboard, __self__).__init__( + 'chronosphere:index/classicDashboard:ClassicDashboard', + resource_name, + __props__, + opts) + + @staticmethod + def get(resource_name: str, + id: pulumi.Input[str], + opts: Optional[pulumi.ResourceOptions] = None, + bucket_id: Optional[pulumi.Input[str]] = None, + collection_id: Optional[pulumi.Input[str]] = None, + dashboard_json: Optional[pulumi.Input[str]] = None) -> 'ClassicDashboard': + """ + Get an existing ClassicDashboard 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. + """ + opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id)) + + __props__ = _ClassicDashboardState.__new__(_ClassicDashboardState) + + __props__.__dict__["bucket_id"] = bucket_id + __props__.__dict__["collection_id"] = collection_id + __props__.__dict__["dashboard_json"] = dashboard_json + return ClassicDashboard(resource_name, opts=opts, __props__=__props__) + + @property + @pulumi.getter(name="bucketId") + def bucket_id(self) -> pulumi.Output[Optional[str]]: + return pulumi.get(self, "bucket_id") + + @property + @pulumi.getter(name="collectionId") + def collection_id(self) -> pulumi.Output[Optional[str]]: + return pulumi.get(self, "collection_id") + + @property + @pulumi.getter(name="dashboardJson") + def dashboard_json(self) -> pulumi.Output[str]: + return pulumi.get(self, "dashboard_json") + diff --git a/sdk/python/chronosphereio_chronosphere/collection.py b/sdk/python/chronosphereio_chronosphere/collection.py new file mode 100644 index 00000000..97634445 --- /dev/null +++ b/sdk/python/chronosphereio_chronosphere/collection.py @@ -0,0 +1,267 @@ +# coding=utf-8 +# *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import copy +import warnings +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +from . import _utilities + +__all__ = ['CollectionArgs', 'Collection'] + +@pulumi.input_type +class CollectionArgs: + def __init__(__self__, *, + name: pulumi.Input[str], + description: Optional[pulumi.Input[str]] = None, + notification_policy_id: Optional[pulumi.Input[str]] = None, + slug: Optional[pulumi.Input[str]] = None, + team_id: Optional[pulumi.Input[str]] = None): + """ + The set of arguments for constructing a Collection resource. + """ + pulumi.set(__self__, "name", name) + if description is not None: + pulumi.set(__self__, "description", description) + if notification_policy_id is not None: + pulumi.set(__self__, "notification_policy_id", notification_policy_id) + if slug is not None: + pulumi.set(__self__, "slug", slug) + if team_id is not None: + pulumi.set(__self__, "team_id", team_id) + + @property + @pulumi.getter + def name(self) -> pulumi.Input[str]: + return pulumi.get(self, "name") + + @name.setter + def name(self, value: pulumi.Input[str]): + pulumi.set(self, "name", value) + + @property + @pulumi.getter + def description(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "description") + + @description.setter + def description(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "description", value) + + @property + @pulumi.getter(name="notificationPolicyId") + def notification_policy_id(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "notification_policy_id") + + @notification_policy_id.setter + def notification_policy_id(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "notification_policy_id", value) + + @property + @pulumi.getter + def slug(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "slug") + + @slug.setter + def slug(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "slug", value) + + @property + @pulumi.getter(name="teamId") + def team_id(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "team_id") + + @team_id.setter + def team_id(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "team_id", value) + + +@pulumi.input_type +class _CollectionState: + def __init__(__self__, *, + description: Optional[pulumi.Input[str]] = None, + name: Optional[pulumi.Input[str]] = None, + notification_policy_id: Optional[pulumi.Input[str]] = None, + slug: Optional[pulumi.Input[str]] = None, + team_id: Optional[pulumi.Input[str]] = None): + """ + Input properties used for looking up and filtering Collection resources. + """ + if description is not None: + pulumi.set(__self__, "description", description) + if name is not None: + pulumi.set(__self__, "name", name) + if notification_policy_id is not None: + pulumi.set(__self__, "notification_policy_id", notification_policy_id) + if slug is not None: + pulumi.set(__self__, "slug", slug) + if team_id is not None: + pulumi.set(__self__, "team_id", team_id) + + @property + @pulumi.getter + def description(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "description") + + @description.setter + def description(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "description", value) + + @property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "name", value) + + @property + @pulumi.getter(name="notificationPolicyId") + def notification_policy_id(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "notification_policy_id") + + @notification_policy_id.setter + def notification_policy_id(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "notification_policy_id", value) + + @property + @pulumi.getter + def slug(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "slug") + + @slug.setter + def slug(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "slug", value) + + @property + @pulumi.getter(name="teamId") + def team_id(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "team_id") + + @team_id.setter + def team_id(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "team_id", value) + + +class Collection(pulumi.CustomResource): + @overload + def __init__(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + description: Optional[pulumi.Input[str]] = None, + name: Optional[pulumi.Input[str]] = None, + notification_policy_id: Optional[pulumi.Input[str]] = None, + slug: Optional[pulumi.Input[str]] = None, + team_id: Optional[pulumi.Input[str]] = None, + __props__=None): + """ + Create a Collection resource with the given unique name, props, and options. + :param str resource_name: The name of the resource. + :param pulumi.ResourceOptions opts: Options for the resource. + """ + ... + @overload + def __init__(__self__, + resource_name: str, + args: CollectionArgs, + opts: Optional[pulumi.ResourceOptions] = None): + """ + Create a Collection resource with the given unique name, props, and options. + :param str resource_name: The name of the resource. + :param CollectionArgs 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(CollectionArgs, 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[str]] = None, + name: Optional[pulumi.Input[str]] = None, + notification_policy_id: Optional[pulumi.Input[str]] = None, + slug: Optional[pulumi.Input[str]] = None, + team_id: Optional[pulumi.Input[str]] = None, + __props__=None): + opts = pulumi.ResourceOptions.merge(_utilities.get_resource_opts_defaults(), opts) + if not isinstance(opts, pulumi.ResourceOptions): + raise TypeError('Expected resource options to be a ResourceOptions instance') + if opts.id is None: + if __props__ is not None: + raise TypeError('__props__ is only valid when passed in combination with a valid opts.id to get an existing resource') + __props__ = CollectionArgs.__new__(CollectionArgs) + + __props__.__dict__["description"] = description + if name is None and not opts.urn: + raise TypeError("Missing required property 'name'") + __props__.__dict__["name"] = name + __props__.__dict__["notification_policy_id"] = notification_policy_id + __props__.__dict__["slug"] = slug + __props__.__dict__["team_id"] = team_id + super(Collection, __self__).__init__( + 'chronosphere:index/collection:Collection', + resource_name, + __props__, + opts) + + @staticmethod + def get(resource_name: str, + id: pulumi.Input[str], + opts: Optional[pulumi.ResourceOptions] = None, + description: Optional[pulumi.Input[str]] = None, + name: Optional[pulumi.Input[str]] = None, + notification_policy_id: Optional[pulumi.Input[str]] = None, + slug: Optional[pulumi.Input[str]] = None, + team_id: Optional[pulumi.Input[str]] = None) -> 'Collection': + """ + Get an existing Collection 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. + """ + opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id)) + + __props__ = _CollectionState.__new__(_CollectionState) + + __props__.__dict__["description"] = description + __props__.__dict__["name"] = name + __props__.__dict__["notification_policy_id"] = notification_policy_id + __props__.__dict__["slug"] = slug + __props__.__dict__["team_id"] = team_id + return Collection(resource_name, opts=opts, __props__=__props__) + + @property + @pulumi.getter + def description(self) -> pulumi.Output[Optional[str]]: + return pulumi.get(self, "description") + + @property + @pulumi.getter + def name(self) -> pulumi.Output[str]: + return pulumi.get(self, "name") + + @property + @pulumi.getter(name="notificationPolicyId") + def notification_policy_id(self) -> pulumi.Output[Optional[str]]: + return pulumi.get(self, "notification_policy_id") + + @property + @pulumi.getter + def slug(self) -> pulumi.Output[str]: + return pulumi.get(self, "slug") + + @property + @pulumi.getter(name="teamId") + def team_id(self) -> pulumi.Output[Optional[str]]: + return pulumi.get(self, "team_id") + diff --git a/sdk/python/chronosphereio_chronosphere/config/__init__.py b/sdk/python/chronosphereio_chronosphere/config/__init__.py new file mode 100644 index 00000000..18853fcb --- /dev/null +++ b/sdk/python/chronosphereio_chronosphere/config/__init__.py @@ -0,0 +1,8 @@ +# coding=utf-8 +# *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import sys +from .vars import _ExportableConfig + +sys.modules[__name__].__class__ = _ExportableConfig diff --git a/sdk/python/chronosphereio_chronosphere/config/__init__.pyi b/sdk/python/chronosphereio_chronosphere/config/__init__.pyi new file mode 100644 index 00000000..7f1a49ee --- /dev/null +++ b/sdk/python/chronosphereio_chronosphere/config/__init__.pyi @@ -0,0 +1,19 @@ +# coding=utf-8 +# *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import copy +import warnings +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +from .. import _utilities + +apiToken: Optional[str] + +entityNamespace: Optional[str] + +org: Optional[str] + +unstable: Optional[bool] + diff --git a/sdk/python/chronosphereio_chronosphere/config/vars.py b/sdk/python/chronosphereio_chronosphere/config/vars.py new file mode 100644 index 00000000..9a4dfb3d --- /dev/null +++ b/sdk/python/chronosphereio_chronosphere/config/vars.py @@ -0,0 +1,33 @@ +# coding=utf-8 +# *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import copy +import warnings +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +from .. import _utilities + +import types + +__config__ = pulumi.Config('chronosphere') + + +class _ExportableConfig(types.ModuleType): + @property + def api_token(self) -> Optional[str]: + return __config__.get('apiToken') or _utilities.get_env('CHRONOSPHERE_API_TOKEN') + + @property + def entity_namespace(self) -> Optional[str]: + return __config__.get('entityNamespace') + + @property + def org(self) -> Optional[str]: + return __config__.get('org') or _utilities.get_env('CHRONOSPHERE_ORG', 'CHRONOSPHERE_ORG_NAME') + + @property + def unstable(self) -> Optional[bool]: + return __config__.get_bool('unstable') + diff --git a/sdk/python/chronosphereio_chronosphere/dashboard.py b/sdk/python/chronosphereio_chronosphere/dashboard.py new file mode 100644 index 00000000..3045596f --- /dev/null +++ b/sdk/python/chronosphereio_chronosphere/dashboard.py @@ -0,0 +1,199 @@ +# coding=utf-8 +# *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import copy +import warnings +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +from . import _utilities + +__all__ = ['DashboardArgs', 'Dashboard'] + +@pulumi.input_type +class DashboardArgs: + def __init__(__self__, *, + dashboard_json: pulumi.Input[str], + collection_id: Optional[pulumi.Input[str]] = None, + slug: Optional[pulumi.Input[str]] = None): + """ + The set of arguments for constructing a Dashboard resource. + """ + pulumi.set(__self__, "dashboard_json", dashboard_json) + if collection_id is not None: + pulumi.set(__self__, "collection_id", collection_id) + if slug is not None: + pulumi.set(__self__, "slug", slug) + + @property + @pulumi.getter(name="dashboardJson") + def dashboard_json(self) -> pulumi.Input[str]: + return pulumi.get(self, "dashboard_json") + + @dashboard_json.setter + def dashboard_json(self, value: pulumi.Input[str]): + pulumi.set(self, "dashboard_json", value) + + @property + @pulumi.getter(name="collectionId") + def collection_id(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "collection_id") + + @collection_id.setter + def collection_id(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "collection_id", value) + + @property + @pulumi.getter + def slug(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "slug") + + @slug.setter + def slug(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "slug", value) + + +@pulumi.input_type +class _DashboardState: + def __init__(__self__, *, + collection_id: Optional[pulumi.Input[str]] = None, + dashboard_json: Optional[pulumi.Input[str]] = None, + slug: Optional[pulumi.Input[str]] = None): + """ + Input properties used for looking up and filtering Dashboard resources. + """ + if collection_id is not None: + pulumi.set(__self__, "collection_id", collection_id) + if dashboard_json is not None: + pulumi.set(__self__, "dashboard_json", dashboard_json) + if slug is not None: + pulumi.set(__self__, "slug", slug) + + @property + @pulumi.getter(name="collectionId") + def collection_id(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "collection_id") + + @collection_id.setter + def collection_id(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "collection_id", value) + + @property + @pulumi.getter(name="dashboardJson") + def dashboard_json(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "dashboard_json") + + @dashboard_json.setter + def dashboard_json(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "dashboard_json", value) + + @property + @pulumi.getter + def slug(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "slug") + + @slug.setter + def slug(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "slug", value) + + +class Dashboard(pulumi.CustomResource): + @overload + def __init__(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + collection_id: Optional[pulumi.Input[str]] = None, + dashboard_json: Optional[pulumi.Input[str]] = None, + slug: Optional[pulumi.Input[str]] = None, + __props__=None): + """ + Create a Dashboard resource with the given unique name, props, and options. + :param str resource_name: The name of the resource. + :param pulumi.ResourceOptions opts: Options for the resource. + """ + ... + @overload + def __init__(__self__, + resource_name: str, + args: DashboardArgs, + opts: Optional[pulumi.ResourceOptions] = None): + """ + Create a Dashboard resource with the given unique name, props, and options. + :param str resource_name: The name of the resource. + :param DashboardArgs 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(DashboardArgs, 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, + collection_id: Optional[pulumi.Input[str]] = None, + dashboard_json: Optional[pulumi.Input[str]] = None, + slug: Optional[pulumi.Input[str]] = None, + __props__=None): + opts = pulumi.ResourceOptions.merge(_utilities.get_resource_opts_defaults(), opts) + if not isinstance(opts, pulumi.ResourceOptions): + raise TypeError('Expected resource options to be a ResourceOptions instance') + if opts.id is None: + if __props__ is not None: + raise TypeError('__props__ is only valid when passed in combination with a valid opts.id to get an existing resource') + __props__ = DashboardArgs.__new__(DashboardArgs) + + __props__.__dict__["collection_id"] = collection_id + if dashboard_json is None and not opts.urn: + raise TypeError("Missing required property 'dashboard_json'") + __props__.__dict__["dashboard_json"] = dashboard_json + __props__.__dict__["slug"] = slug + super(Dashboard, __self__).__init__( + 'chronosphere:index/dashboard:Dashboard', + resource_name, + __props__, + opts) + + @staticmethod + def get(resource_name: str, + id: pulumi.Input[str], + opts: Optional[pulumi.ResourceOptions] = None, + collection_id: Optional[pulumi.Input[str]] = None, + dashboard_json: Optional[pulumi.Input[str]] = None, + slug: Optional[pulumi.Input[str]] = None) -> 'Dashboard': + """ + Get an existing Dashboard 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. + """ + opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id)) + + __props__ = _DashboardState.__new__(_DashboardState) + + __props__.__dict__["collection_id"] = collection_id + __props__.__dict__["dashboard_json"] = dashboard_json + __props__.__dict__["slug"] = slug + return Dashboard(resource_name, opts=opts, __props__=__props__) + + @property + @pulumi.getter(name="collectionId") + def collection_id(self) -> pulumi.Output[Optional[str]]: + return pulumi.get(self, "collection_id") + + @property + @pulumi.getter(name="dashboardJson") + def dashboard_json(self) -> pulumi.Output[str]: + return pulumi.get(self, "dashboard_json") + + @property + @pulumi.getter + def slug(self) -> pulumi.Output[str]: + return pulumi.get(self, "slug") + diff --git a/sdk/python/chronosphereio_chronosphere/derived_label.py b/sdk/python/chronosphereio_chronosphere/derived_label.py new file mode 100644 index 00000000..f2099f37 --- /dev/null +++ b/sdk/python/chronosphereio_chronosphere/derived_label.py @@ -0,0 +1,305 @@ +# coding=utf-8 +# *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import copy +import warnings +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +from . import _utilities +from . import outputs +from ._inputs import * + +__all__ = ['DerivedLabelArgs', 'DerivedLabel'] + +@pulumi.input_type +class DerivedLabelArgs: + def __init__(__self__, *, + label_name: pulumi.Input[str], + metric_label: pulumi.Input['DerivedLabelMetricLabelArgs'], + name: pulumi.Input[str], + description: Optional[pulumi.Input[str]] = None, + existing_label_policy: Optional[pulumi.Input[str]] = None, + slug: Optional[pulumi.Input[str]] = None): + """ + The set of arguments for constructing a DerivedLabel resource. + """ + pulumi.set(__self__, "label_name", label_name) + pulumi.set(__self__, "metric_label", metric_label) + pulumi.set(__self__, "name", name) + if description is not None: + pulumi.set(__self__, "description", description) + if existing_label_policy is not None: + pulumi.set(__self__, "existing_label_policy", existing_label_policy) + if slug is not None: + pulumi.set(__self__, "slug", slug) + + @property + @pulumi.getter(name="labelName") + def label_name(self) -> pulumi.Input[str]: + return pulumi.get(self, "label_name") + + @label_name.setter + def label_name(self, value: pulumi.Input[str]): + pulumi.set(self, "label_name", value) + + @property + @pulumi.getter(name="metricLabel") + def metric_label(self) -> pulumi.Input['DerivedLabelMetricLabelArgs']: + return pulumi.get(self, "metric_label") + + @metric_label.setter + def metric_label(self, value: pulumi.Input['DerivedLabelMetricLabelArgs']): + pulumi.set(self, "metric_label", value) + + @property + @pulumi.getter + def name(self) -> pulumi.Input[str]: + return pulumi.get(self, "name") + + @name.setter + def name(self, value: pulumi.Input[str]): + pulumi.set(self, "name", value) + + @property + @pulumi.getter + def description(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "description") + + @description.setter + def description(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "description", value) + + @property + @pulumi.getter(name="existingLabelPolicy") + def existing_label_policy(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "existing_label_policy") + + @existing_label_policy.setter + def existing_label_policy(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "existing_label_policy", value) + + @property + @pulumi.getter + def slug(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "slug") + + @slug.setter + def slug(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "slug", value) + + +@pulumi.input_type +class _DerivedLabelState: + def __init__(__self__, *, + description: Optional[pulumi.Input[str]] = None, + existing_label_policy: Optional[pulumi.Input[str]] = None, + label_name: Optional[pulumi.Input[str]] = None, + metric_label: Optional[pulumi.Input['DerivedLabelMetricLabelArgs']] = None, + name: Optional[pulumi.Input[str]] = None, + slug: Optional[pulumi.Input[str]] = None): + """ + Input properties used for looking up and filtering DerivedLabel resources. + """ + if description is not None: + pulumi.set(__self__, "description", description) + if existing_label_policy is not None: + pulumi.set(__self__, "existing_label_policy", existing_label_policy) + if label_name is not None: + pulumi.set(__self__, "label_name", label_name) + if metric_label is not None: + pulumi.set(__self__, "metric_label", metric_label) + if name is not None: + pulumi.set(__self__, "name", name) + if slug is not None: + pulumi.set(__self__, "slug", slug) + + @property + @pulumi.getter + def description(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "description") + + @description.setter + def description(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "description", value) + + @property + @pulumi.getter(name="existingLabelPolicy") + def existing_label_policy(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "existing_label_policy") + + @existing_label_policy.setter + def existing_label_policy(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "existing_label_policy", value) + + @property + @pulumi.getter(name="labelName") + def label_name(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "label_name") + + @label_name.setter + def label_name(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "label_name", value) + + @property + @pulumi.getter(name="metricLabel") + def metric_label(self) -> Optional[pulumi.Input['DerivedLabelMetricLabelArgs']]: + return pulumi.get(self, "metric_label") + + @metric_label.setter + def metric_label(self, value: Optional[pulumi.Input['DerivedLabelMetricLabelArgs']]): + pulumi.set(self, "metric_label", value) + + @property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "name", value) + + @property + @pulumi.getter + def slug(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "slug") + + @slug.setter + def slug(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "slug", value) + + +class DerivedLabel(pulumi.CustomResource): + @overload + def __init__(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + description: Optional[pulumi.Input[str]] = None, + existing_label_policy: Optional[pulumi.Input[str]] = None, + label_name: Optional[pulumi.Input[str]] = None, + metric_label: Optional[pulumi.Input[pulumi.InputType['DerivedLabelMetricLabelArgs']]] = None, + name: Optional[pulumi.Input[str]] = None, + slug: Optional[pulumi.Input[str]] = None, + __props__=None): + """ + Create a DerivedLabel resource with the given unique name, props, and options. + :param str resource_name: The name of the resource. + :param pulumi.ResourceOptions opts: Options for the resource. + """ + ... + @overload + def __init__(__self__, + resource_name: str, + args: DerivedLabelArgs, + opts: Optional[pulumi.ResourceOptions] = None): + """ + Create a DerivedLabel resource with the given unique name, props, and options. + :param str resource_name: The name of the resource. + :param DerivedLabelArgs 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(DerivedLabelArgs, 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[str]] = None, + existing_label_policy: Optional[pulumi.Input[str]] = None, + label_name: Optional[pulumi.Input[str]] = None, + metric_label: Optional[pulumi.Input[pulumi.InputType['DerivedLabelMetricLabelArgs']]] = None, + name: Optional[pulumi.Input[str]] = None, + slug: Optional[pulumi.Input[str]] = None, + __props__=None): + opts = pulumi.ResourceOptions.merge(_utilities.get_resource_opts_defaults(), opts) + if not isinstance(opts, pulumi.ResourceOptions): + raise TypeError('Expected resource options to be a ResourceOptions instance') + if opts.id is None: + if __props__ is not None: + raise TypeError('__props__ is only valid when passed in combination with a valid opts.id to get an existing resource') + __props__ = DerivedLabelArgs.__new__(DerivedLabelArgs) + + __props__.__dict__["description"] = description + __props__.__dict__["existing_label_policy"] = existing_label_policy + if label_name is None and not opts.urn: + raise TypeError("Missing required property 'label_name'") + __props__.__dict__["label_name"] = label_name + if metric_label is None and not opts.urn: + raise TypeError("Missing required property 'metric_label'") + __props__.__dict__["metric_label"] = metric_label + if name is None and not opts.urn: + raise TypeError("Missing required property 'name'") + __props__.__dict__["name"] = name + __props__.__dict__["slug"] = slug + super(DerivedLabel, __self__).__init__( + 'chronosphere:index/derivedLabel:DerivedLabel', + resource_name, + __props__, + opts) + + @staticmethod + def get(resource_name: str, + id: pulumi.Input[str], + opts: Optional[pulumi.ResourceOptions] = None, + description: Optional[pulumi.Input[str]] = None, + existing_label_policy: Optional[pulumi.Input[str]] = None, + label_name: Optional[pulumi.Input[str]] = None, + metric_label: Optional[pulumi.Input[pulumi.InputType['DerivedLabelMetricLabelArgs']]] = None, + name: Optional[pulumi.Input[str]] = None, + slug: Optional[pulumi.Input[str]] = None) -> 'DerivedLabel': + """ + Get an existing DerivedLabel 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. + """ + opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id)) + + __props__ = _DerivedLabelState.__new__(_DerivedLabelState) + + __props__.__dict__["description"] = description + __props__.__dict__["existing_label_policy"] = existing_label_policy + __props__.__dict__["label_name"] = label_name + __props__.__dict__["metric_label"] = metric_label + __props__.__dict__["name"] = name + __props__.__dict__["slug"] = slug + return DerivedLabel(resource_name, opts=opts, __props__=__props__) + + @property + @pulumi.getter + def description(self) -> pulumi.Output[Optional[str]]: + return pulumi.get(self, "description") + + @property + @pulumi.getter(name="existingLabelPolicy") + def existing_label_policy(self) -> pulumi.Output[Optional[str]]: + return pulumi.get(self, "existing_label_policy") + + @property + @pulumi.getter(name="labelName") + def label_name(self) -> pulumi.Output[str]: + return pulumi.get(self, "label_name") + + @property + @pulumi.getter(name="metricLabel") + def metric_label(self) -> pulumi.Output['outputs.DerivedLabelMetricLabel']: + return pulumi.get(self, "metric_label") + + @property + @pulumi.getter + def name(self) -> pulumi.Output[str]: + return pulumi.get(self, "name") + + @property + @pulumi.getter + def slug(self) -> pulumi.Output[str]: + return pulumi.get(self, "slug") + diff --git a/sdk/python/chronosphereio_chronosphere/derived_metric.py b/sdk/python/chronosphereio_chronosphere/derived_metric.py new file mode 100644 index 00000000..3af80504 --- /dev/null +++ b/sdk/python/chronosphereio_chronosphere/derived_metric.py @@ -0,0 +1,271 @@ +# coding=utf-8 +# *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import copy +import warnings +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +from . import _utilities +from . import outputs +from ._inputs import * + +__all__ = ['DerivedMetricArgs', 'DerivedMetric'] + +@pulumi.input_type +class DerivedMetricArgs: + def __init__(__self__, *, + metric_name: pulumi.Input[str], + name: pulumi.Input[str], + queries: pulumi.Input[Sequence[pulumi.Input['DerivedMetricQueryArgs']]], + description: Optional[pulumi.Input[str]] = None, + slug: Optional[pulumi.Input[str]] = None): + """ + The set of arguments for constructing a DerivedMetric resource. + """ + pulumi.set(__self__, "metric_name", metric_name) + pulumi.set(__self__, "name", name) + pulumi.set(__self__, "queries", queries) + if description is not None: + pulumi.set(__self__, "description", description) + if slug is not None: + pulumi.set(__self__, "slug", slug) + + @property + @pulumi.getter(name="metricName") + def metric_name(self) -> pulumi.Input[str]: + return pulumi.get(self, "metric_name") + + @metric_name.setter + def metric_name(self, value: pulumi.Input[str]): + pulumi.set(self, "metric_name", value) + + @property + @pulumi.getter + def name(self) -> pulumi.Input[str]: + return pulumi.get(self, "name") + + @name.setter + def name(self, value: pulumi.Input[str]): + pulumi.set(self, "name", value) + + @property + @pulumi.getter + def queries(self) -> pulumi.Input[Sequence[pulumi.Input['DerivedMetricQueryArgs']]]: + return pulumi.get(self, "queries") + + @queries.setter + def queries(self, value: pulumi.Input[Sequence[pulumi.Input['DerivedMetricQueryArgs']]]): + pulumi.set(self, "queries", value) + + @property + @pulumi.getter + def description(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "description") + + @description.setter + def description(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "description", value) + + @property + @pulumi.getter + def slug(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "slug") + + @slug.setter + def slug(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "slug", value) + + +@pulumi.input_type +class _DerivedMetricState: + def __init__(__self__, *, + description: Optional[pulumi.Input[str]] = None, + metric_name: Optional[pulumi.Input[str]] = None, + name: Optional[pulumi.Input[str]] = None, + queries: Optional[pulumi.Input[Sequence[pulumi.Input['DerivedMetricQueryArgs']]]] = None, + slug: Optional[pulumi.Input[str]] = None): + """ + Input properties used for looking up and filtering DerivedMetric resources. + """ + if description is not None: + pulumi.set(__self__, "description", description) + if metric_name is not None: + pulumi.set(__self__, "metric_name", metric_name) + if name is not None: + pulumi.set(__self__, "name", name) + if queries is not None: + pulumi.set(__self__, "queries", queries) + if slug is not None: + pulumi.set(__self__, "slug", slug) + + @property + @pulumi.getter + def description(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "description") + + @description.setter + def description(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "description", value) + + @property + @pulumi.getter(name="metricName") + def metric_name(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "metric_name") + + @metric_name.setter + def metric_name(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "metric_name", value) + + @property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "name", value) + + @property + @pulumi.getter + def queries(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['DerivedMetricQueryArgs']]]]: + return pulumi.get(self, "queries") + + @queries.setter + def queries(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['DerivedMetricQueryArgs']]]]): + pulumi.set(self, "queries", value) + + @property + @pulumi.getter + def slug(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "slug") + + @slug.setter + def slug(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "slug", value) + + +class DerivedMetric(pulumi.CustomResource): + @overload + def __init__(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + description: Optional[pulumi.Input[str]] = None, + metric_name: Optional[pulumi.Input[str]] = None, + name: Optional[pulumi.Input[str]] = None, + queries: Optional[pulumi.Input[Sequence[pulumi.Input[pulumi.InputType['DerivedMetricQueryArgs']]]]] = None, + slug: Optional[pulumi.Input[str]] = None, + __props__=None): + """ + Create a DerivedMetric resource with the given unique name, props, and options. + :param str resource_name: The name of the resource. + :param pulumi.ResourceOptions opts: Options for the resource. + """ + ... + @overload + def __init__(__self__, + resource_name: str, + args: DerivedMetricArgs, + opts: Optional[pulumi.ResourceOptions] = None): + """ + Create a DerivedMetric resource with the given unique name, props, and options. + :param str resource_name: The name of the resource. + :param DerivedMetricArgs 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(DerivedMetricArgs, 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[str]] = None, + metric_name: Optional[pulumi.Input[str]] = None, + name: Optional[pulumi.Input[str]] = None, + queries: Optional[pulumi.Input[Sequence[pulumi.Input[pulumi.InputType['DerivedMetricQueryArgs']]]]] = None, + slug: Optional[pulumi.Input[str]] = None, + __props__=None): + opts = pulumi.ResourceOptions.merge(_utilities.get_resource_opts_defaults(), opts) + if not isinstance(opts, pulumi.ResourceOptions): + raise TypeError('Expected resource options to be a ResourceOptions instance') + if opts.id is None: + if __props__ is not None: + raise TypeError('__props__ is only valid when passed in combination with a valid opts.id to get an existing resource') + __props__ = DerivedMetricArgs.__new__(DerivedMetricArgs) + + __props__.__dict__["description"] = description + if metric_name is None and not opts.urn: + raise TypeError("Missing required property 'metric_name'") + __props__.__dict__["metric_name"] = metric_name + if name is None and not opts.urn: + raise TypeError("Missing required property 'name'") + __props__.__dict__["name"] = name + if queries is None and not opts.urn: + raise TypeError("Missing required property 'queries'") + __props__.__dict__["queries"] = queries + __props__.__dict__["slug"] = slug + super(DerivedMetric, __self__).__init__( + 'chronosphere:index/derivedMetric:DerivedMetric', + resource_name, + __props__, + opts) + + @staticmethod + def get(resource_name: str, + id: pulumi.Input[str], + opts: Optional[pulumi.ResourceOptions] = None, + description: Optional[pulumi.Input[str]] = None, + metric_name: Optional[pulumi.Input[str]] = None, + name: Optional[pulumi.Input[str]] = None, + queries: Optional[pulumi.Input[Sequence[pulumi.Input[pulumi.InputType['DerivedMetricQueryArgs']]]]] = None, + slug: Optional[pulumi.Input[str]] = None) -> 'DerivedMetric': + """ + Get an existing DerivedMetric 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. + """ + opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id)) + + __props__ = _DerivedMetricState.__new__(_DerivedMetricState) + + __props__.__dict__["description"] = description + __props__.__dict__["metric_name"] = metric_name + __props__.__dict__["name"] = name + __props__.__dict__["queries"] = queries + __props__.__dict__["slug"] = slug + return DerivedMetric(resource_name, opts=opts, __props__=__props__) + + @property + @pulumi.getter + def description(self) -> pulumi.Output[Optional[str]]: + return pulumi.get(self, "description") + + @property + @pulumi.getter(name="metricName") + def metric_name(self) -> pulumi.Output[str]: + return pulumi.get(self, "metric_name") + + @property + @pulumi.getter + def name(self) -> pulumi.Output[str]: + return pulumi.get(self, "name") + + @property + @pulumi.getter + def queries(self) -> pulumi.Output[Sequence['outputs.DerivedMetricQuery']]: + return pulumi.get(self, "queries") + + @property + @pulumi.getter + def slug(self) -> pulumi.Output[str]: + return pulumi.get(self, "slug") + diff --git a/sdk/python/chronosphereio_chronosphere/drop_rule.py b/sdk/python/chronosphereio_chronosphere/drop_rule.py new file mode 100644 index 00000000..59d7f5a2 --- /dev/null +++ b/sdk/python/chronosphereio_chronosphere/drop_rule.py @@ -0,0 +1,372 @@ +# coding=utf-8 +# *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import copy +import warnings +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +from . import _utilities +from . import outputs +from ._inputs import * + +__all__ = ['DropRuleArgs', 'DropRule'] + +@pulumi.input_type +class DropRuleArgs: + def __init__(__self__, *, + name: pulumi.Input[str], + queries: pulumi.Input[Sequence[pulumi.Input[str]]], + activated_drop_duration: Optional[pulumi.Input[str]] = None, + active: Optional[pulumi.Input[bool]] = None, + conditional_drop: Optional[pulumi.Input[bool]] = None, + rate_limit_threshold: Optional[pulumi.Input[float]] = None, + slug: Optional[pulumi.Input[str]] = None, + value_based_drop: Optional[pulumi.Input['DropRuleValueBasedDropArgs']] = None): + """ + The set of arguments for constructing a DropRule resource. + """ + pulumi.set(__self__, "name", name) + pulumi.set(__self__, "queries", queries) + if activated_drop_duration is not None: + pulumi.set(__self__, "activated_drop_duration", activated_drop_duration) + if active is not None: + pulumi.set(__self__, "active", active) + if conditional_drop is not None: + pulumi.set(__self__, "conditional_drop", conditional_drop) + if rate_limit_threshold is not None: + pulumi.set(__self__, "rate_limit_threshold", rate_limit_threshold) + if slug is not None: + pulumi.set(__self__, "slug", slug) + if value_based_drop is not None: + pulumi.set(__self__, "value_based_drop", value_based_drop) + + @property + @pulumi.getter + def name(self) -> pulumi.Input[str]: + return pulumi.get(self, "name") + + @name.setter + def name(self, value: pulumi.Input[str]): + pulumi.set(self, "name", value) + + @property + @pulumi.getter + def queries(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]: + return pulumi.get(self, "queries") + + @queries.setter + def queries(self, value: pulumi.Input[Sequence[pulumi.Input[str]]]): + pulumi.set(self, "queries", value) + + @property + @pulumi.getter(name="activatedDropDuration") + def activated_drop_duration(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "activated_drop_duration") + + @activated_drop_duration.setter + def activated_drop_duration(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "activated_drop_duration", value) + + @property + @pulumi.getter + def active(self) -> Optional[pulumi.Input[bool]]: + return pulumi.get(self, "active") + + @active.setter + def active(self, value: Optional[pulumi.Input[bool]]): + pulumi.set(self, "active", value) + + @property + @pulumi.getter(name="conditionalDrop") + def conditional_drop(self) -> Optional[pulumi.Input[bool]]: + return pulumi.get(self, "conditional_drop") + + @conditional_drop.setter + def conditional_drop(self, value: Optional[pulumi.Input[bool]]): + pulumi.set(self, "conditional_drop", value) + + @property + @pulumi.getter(name="rateLimitThreshold") + def rate_limit_threshold(self) -> Optional[pulumi.Input[float]]: + return pulumi.get(self, "rate_limit_threshold") + + @rate_limit_threshold.setter + def rate_limit_threshold(self, value: Optional[pulumi.Input[float]]): + pulumi.set(self, "rate_limit_threshold", value) + + @property + @pulumi.getter + def slug(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "slug") + + @slug.setter + def slug(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "slug", value) + + @property + @pulumi.getter(name="valueBasedDrop") + def value_based_drop(self) -> Optional[pulumi.Input['DropRuleValueBasedDropArgs']]: + return pulumi.get(self, "value_based_drop") + + @value_based_drop.setter + def value_based_drop(self, value: Optional[pulumi.Input['DropRuleValueBasedDropArgs']]): + pulumi.set(self, "value_based_drop", value) + + +@pulumi.input_type +class _DropRuleState: + def __init__(__self__, *, + activated_drop_duration: Optional[pulumi.Input[str]] = None, + active: Optional[pulumi.Input[bool]] = None, + conditional_drop: Optional[pulumi.Input[bool]] = None, + name: Optional[pulumi.Input[str]] = None, + queries: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None, + rate_limit_threshold: Optional[pulumi.Input[float]] = None, + slug: Optional[pulumi.Input[str]] = None, + value_based_drop: Optional[pulumi.Input['DropRuleValueBasedDropArgs']] = None): + """ + Input properties used for looking up and filtering DropRule resources. + """ + if activated_drop_duration is not None: + pulumi.set(__self__, "activated_drop_duration", activated_drop_duration) + if active is not None: + pulumi.set(__self__, "active", active) + if conditional_drop is not None: + pulumi.set(__self__, "conditional_drop", conditional_drop) + if name is not None: + pulumi.set(__self__, "name", name) + if queries is not None: + pulumi.set(__self__, "queries", queries) + if rate_limit_threshold is not None: + pulumi.set(__self__, "rate_limit_threshold", rate_limit_threshold) + if slug is not None: + pulumi.set(__self__, "slug", slug) + if value_based_drop is not None: + pulumi.set(__self__, "value_based_drop", value_based_drop) + + @property + @pulumi.getter(name="activatedDropDuration") + def activated_drop_duration(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "activated_drop_duration") + + @activated_drop_duration.setter + def activated_drop_duration(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "activated_drop_duration", value) + + @property + @pulumi.getter + def active(self) -> Optional[pulumi.Input[bool]]: + return pulumi.get(self, "active") + + @active.setter + def active(self, value: Optional[pulumi.Input[bool]]): + pulumi.set(self, "active", value) + + @property + @pulumi.getter(name="conditionalDrop") + def conditional_drop(self) -> Optional[pulumi.Input[bool]]: + return pulumi.get(self, "conditional_drop") + + @conditional_drop.setter + def conditional_drop(self, value: Optional[pulumi.Input[bool]]): + pulumi.set(self, "conditional_drop", value) + + @property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "name", value) + + @property + @pulumi.getter + def queries(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]: + return pulumi.get(self, "queries") + + @queries.setter + def queries(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]): + pulumi.set(self, "queries", value) + + @property + @pulumi.getter(name="rateLimitThreshold") + def rate_limit_threshold(self) -> Optional[pulumi.Input[float]]: + return pulumi.get(self, "rate_limit_threshold") + + @rate_limit_threshold.setter + def rate_limit_threshold(self, value: Optional[pulumi.Input[float]]): + pulumi.set(self, "rate_limit_threshold", value) + + @property + @pulumi.getter + def slug(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "slug") + + @slug.setter + def slug(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "slug", value) + + @property + @pulumi.getter(name="valueBasedDrop") + def value_based_drop(self) -> Optional[pulumi.Input['DropRuleValueBasedDropArgs']]: + return pulumi.get(self, "value_based_drop") + + @value_based_drop.setter + def value_based_drop(self, value: Optional[pulumi.Input['DropRuleValueBasedDropArgs']]): + pulumi.set(self, "value_based_drop", value) + + +class DropRule(pulumi.CustomResource): + @overload + def __init__(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + activated_drop_duration: Optional[pulumi.Input[str]] = None, + active: Optional[pulumi.Input[bool]] = None, + conditional_drop: Optional[pulumi.Input[bool]] = None, + name: Optional[pulumi.Input[str]] = None, + queries: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None, + rate_limit_threshold: Optional[pulumi.Input[float]] = None, + slug: Optional[pulumi.Input[str]] = None, + value_based_drop: Optional[pulumi.Input[pulumi.InputType['DropRuleValueBasedDropArgs']]] = None, + __props__=None): + """ + Create a DropRule resource with the given unique name, props, and options. + :param str resource_name: The name of the resource. + :param pulumi.ResourceOptions opts: Options for the resource. + """ + ... + @overload + def __init__(__self__, + resource_name: str, + args: DropRuleArgs, + opts: Optional[pulumi.ResourceOptions] = None): + """ + Create a DropRule resource with the given unique name, props, and options. + :param str resource_name: The name of the resource. + :param DropRuleArgs 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(DropRuleArgs, 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, + activated_drop_duration: Optional[pulumi.Input[str]] = None, + active: Optional[pulumi.Input[bool]] = None, + conditional_drop: Optional[pulumi.Input[bool]] = None, + name: Optional[pulumi.Input[str]] = None, + queries: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None, + rate_limit_threshold: Optional[pulumi.Input[float]] = None, + slug: Optional[pulumi.Input[str]] = None, + value_based_drop: Optional[pulumi.Input[pulumi.InputType['DropRuleValueBasedDropArgs']]] = 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__ = DropRuleArgs.__new__(DropRuleArgs) + + __props__.__dict__["activated_drop_duration"] = activated_drop_duration + __props__.__dict__["active"] = active + __props__.__dict__["conditional_drop"] = conditional_drop + if name is None and not opts.urn: + raise TypeError("Missing required property 'name'") + __props__.__dict__["name"] = name + if queries is None and not opts.urn: + raise TypeError("Missing required property 'queries'") + __props__.__dict__["queries"] = queries + __props__.__dict__["rate_limit_threshold"] = rate_limit_threshold + __props__.__dict__["slug"] = slug + __props__.__dict__["value_based_drop"] = value_based_drop + super(DropRule, __self__).__init__( + 'chronosphere:index/dropRule:DropRule', + resource_name, + __props__, + opts) + + @staticmethod + def get(resource_name: str, + id: pulumi.Input[str], + opts: Optional[pulumi.ResourceOptions] = None, + activated_drop_duration: Optional[pulumi.Input[str]] = None, + active: Optional[pulumi.Input[bool]] = None, + conditional_drop: Optional[pulumi.Input[bool]] = None, + name: Optional[pulumi.Input[str]] = None, + queries: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None, + rate_limit_threshold: Optional[pulumi.Input[float]] = None, + slug: Optional[pulumi.Input[str]] = None, + value_based_drop: Optional[pulumi.Input[pulumi.InputType['DropRuleValueBasedDropArgs']]] = None) -> 'DropRule': + """ + Get an existing DropRule 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. + """ + opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id)) + + __props__ = _DropRuleState.__new__(_DropRuleState) + + __props__.__dict__["activated_drop_duration"] = activated_drop_duration + __props__.__dict__["active"] = active + __props__.__dict__["conditional_drop"] = conditional_drop + __props__.__dict__["name"] = name + __props__.__dict__["queries"] = queries + __props__.__dict__["rate_limit_threshold"] = rate_limit_threshold + __props__.__dict__["slug"] = slug + __props__.__dict__["value_based_drop"] = value_based_drop + return DropRule(resource_name, opts=opts, __props__=__props__) + + @property + @pulumi.getter(name="activatedDropDuration") + def activated_drop_duration(self) -> pulumi.Output[Optional[str]]: + return pulumi.get(self, "activated_drop_duration") + + @property + @pulumi.getter + def active(self) -> pulumi.Output[Optional[bool]]: + return pulumi.get(self, "active") + + @property + @pulumi.getter(name="conditionalDrop") + def conditional_drop(self) -> pulumi.Output[Optional[bool]]: + return pulumi.get(self, "conditional_drop") + + @property + @pulumi.getter + def name(self) -> pulumi.Output[str]: + return pulumi.get(self, "name") + + @property + @pulumi.getter + def queries(self) -> pulumi.Output[Sequence[str]]: + return pulumi.get(self, "queries") + + @property + @pulumi.getter(name="rateLimitThreshold") + def rate_limit_threshold(self) -> pulumi.Output[Optional[float]]: + return pulumi.get(self, "rate_limit_threshold") + + @property + @pulumi.getter + def slug(self) -> pulumi.Output[str]: + return pulumi.get(self, "slug") + + @property + @pulumi.getter(name="valueBasedDrop") + def value_based_drop(self) -> pulumi.Output[Optional['outputs.DropRuleValueBasedDrop']]: + return pulumi.get(self, "value_based_drop") + diff --git a/sdk/python/chronosphereio_chronosphere/email_alert_notifier.py b/sdk/python/chronosphereio_chronosphere/email_alert_notifier.py new file mode 100644 index 00000000..baf8168b --- /dev/null +++ b/sdk/python/chronosphereio_chronosphere/email_alert_notifier.py @@ -0,0 +1,302 @@ +# coding=utf-8 +# *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import copy +import warnings +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +from . import _utilities + +__all__ = ['EmailAlertNotifierArgs', 'EmailAlertNotifier'] + +@pulumi.input_type +class EmailAlertNotifierArgs: + def __init__(__self__, *, + name: pulumi.Input[str], + to: pulumi.Input[str], + html: Optional[pulumi.Input[str]] = None, + send_resolved: Optional[pulumi.Input[bool]] = None, + slug: Optional[pulumi.Input[str]] = None, + text: Optional[pulumi.Input[str]] = None): + """ + The set of arguments for constructing a EmailAlertNotifier resource. + """ + pulumi.set(__self__, "name", name) + pulumi.set(__self__, "to", to) + if html is not None: + pulumi.set(__self__, "html", html) + if send_resolved is not None: + pulumi.set(__self__, "send_resolved", send_resolved) + if slug is not None: + pulumi.set(__self__, "slug", slug) + if text is not None: + pulumi.set(__self__, "text", text) + + @property + @pulumi.getter + def name(self) -> pulumi.Input[str]: + return pulumi.get(self, "name") + + @name.setter + def name(self, value: pulumi.Input[str]): + pulumi.set(self, "name", value) + + @property + @pulumi.getter + def to(self) -> pulumi.Input[str]: + return pulumi.get(self, "to") + + @to.setter + def to(self, value: pulumi.Input[str]): + pulumi.set(self, "to", value) + + @property + @pulumi.getter + def html(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "html") + + @html.setter + def html(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "html", value) + + @property + @pulumi.getter(name="sendResolved") + def send_resolved(self) -> Optional[pulumi.Input[bool]]: + return pulumi.get(self, "send_resolved") + + @send_resolved.setter + def send_resolved(self, value: Optional[pulumi.Input[bool]]): + pulumi.set(self, "send_resolved", value) + + @property + @pulumi.getter + def slug(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "slug") + + @slug.setter + def slug(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "slug", value) + + @property + @pulumi.getter + def text(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "text") + + @text.setter + def text(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "text", value) + + +@pulumi.input_type +class _EmailAlertNotifierState: + def __init__(__self__, *, + html: Optional[pulumi.Input[str]] = None, + name: Optional[pulumi.Input[str]] = None, + send_resolved: Optional[pulumi.Input[bool]] = None, + slug: Optional[pulumi.Input[str]] = None, + text: Optional[pulumi.Input[str]] = None, + to: Optional[pulumi.Input[str]] = None): + """ + Input properties used for looking up and filtering EmailAlertNotifier resources. + """ + if html is not None: + pulumi.set(__self__, "html", html) + if name is not None: + pulumi.set(__self__, "name", name) + if send_resolved is not None: + pulumi.set(__self__, "send_resolved", send_resolved) + if slug is not None: + pulumi.set(__self__, "slug", slug) + if text is not None: + pulumi.set(__self__, "text", text) + if to is not None: + pulumi.set(__self__, "to", to) + + @property + @pulumi.getter + def html(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "html") + + @html.setter + def html(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "html", value) + + @property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "name", value) + + @property + @pulumi.getter(name="sendResolved") + def send_resolved(self) -> Optional[pulumi.Input[bool]]: + return pulumi.get(self, "send_resolved") + + @send_resolved.setter + def send_resolved(self, value: Optional[pulumi.Input[bool]]): + pulumi.set(self, "send_resolved", value) + + @property + @pulumi.getter + def slug(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "slug") + + @slug.setter + def slug(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "slug", value) + + @property + @pulumi.getter + def text(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "text") + + @text.setter + def text(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "text", value) + + @property + @pulumi.getter + def to(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "to") + + @to.setter + def to(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "to", value) + + +class EmailAlertNotifier(pulumi.CustomResource): + @overload + def __init__(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + html: Optional[pulumi.Input[str]] = None, + name: Optional[pulumi.Input[str]] = None, + send_resolved: Optional[pulumi.Input[bool]] = None, + slug: Optional[pulumi.Input[str]] = None, + text: Optional[pulumi.Input[str]] = None, + to: Optional[pulumi.Input[str]] = None, + __props__=None): + """ + Create a EmailAlertNotifier resource with the given unique name, props, and options. + :param str resource_name: The name of the resource. + :param pulumi.ResourceOptions opts: Options for the resource. + """ + ... + @overload + def __init__(__self__, + resource_name: str, + args: EmailAlertNotifierArgs, + opts: Optional[pulumi.ResourceOptions] = None): + """ + Create a EmailAlertNotifier resource with the given unique name, props, and options. + :param str resource_name: The name of the resource. + :param EmailAlertNotifierArgs 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(EmailAlertNotifierArgs, 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, + html: Optional[pulumi.Input[str]] = None, + name: Optional[pulumi.Input[str]] = None, + send_resolved: Optional[pulumi.Input[bool]] = None, + slug: Optional[pulumi.Input[str]] = None, + text: Optional[pulumi.Input[str]] = None, + to: Optional[pulumi.Input[str]] = None, + __props__=None): + opts = pulumi.ResourceOptions.merge(_utilities.get_resource_opts_defaults(), opts) + if not isinstance(opts, pulumi.ResourceOptions): + raise TypeError('Expected resource options to be a ResourceOptions instance') + if opts.id is None: + if __props__ is not None: + raise TypeError('__props__ is only valid when passed in combination with a valid opts.id to get an existing resource') + __props__ = EmailAlertNotifierArgs.__new__(EmailAlertNotifierArgs) + + __props__.__dict__["html"] = html + if name is None and not opts.urn: + raise TypeError("Missing required property 'name'") + __props__.__dict__["name"] = name + __props__.__dict__["send_resolved"] = send_resolved + __props__.__dict__["slug"] = slug + __props__.__dict__["text"] = text + if to is None and not opts.urn: + raise TypeError("Missing required property 'to'") + __props__.__dict__["to"] = to + super(EmailAlertNotifier, __self__).__init__( + 'chronosphere:index/emailAlertNotifier:EmailAlertNotifier', + resource_name, + __props__, + opts) + + @staticmethod + def get(resource_name: str, + id: pulumi.Input[str], + opts: Optional[pulumi.ResourceOptions] = None, + html: Optional[pulumi.Input[str]] = None, + name: Optional[pulumi.Input[str]] = None, + send_resolved: Optional[pulumi.Input[bool]] = None, + slug: Optional[pulumi.Input[str]] = None, + text: Optional[pulumi.Input[str]] = None, + to: Optional[pulumi.Input[str]] = None) -> 'EmailAlertNotifier': + """ + Get an existing EmailAlertNotifier 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. + """ + opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id)) + + __props__ = _EmailAlertNotifierState.__new__(_EmailAlertNotifierState) + + __props__.__dict__["html"] = html + __props__.__dict__["name"] = name + __props__.__dict__["send_resolved"] = send_resolved + __props__.__dict__["slug"] = slug + __props__.__dict__["text"] = text + __props__.__dict__["to"] = to + return EmailAlertNotifier(resource_name, opts=opts, __props__=__props__) + + @property + @pulumi.getter + def html(self) -> pulumi.Output[Optional[str]]: + return pulumi.get(self, "html") + + @property + @pulumi.getter + def name(self) -> pulumi.Output[str]: + return pulumi.get(self, "name") + + @property + @pulumi.getter(name="sendResolved") + def send_resolved(self) -> pulumi.Output[Optional[bool]]: + return pulumi.get(self, "send_resolved") + + @property + @pulumi.getter + def slug(self) -> pulumi.Output[str]: + return pulumi.get(self, "slug") + + @property + @pulumi.getter + def text(self) -> pulumi.Output[Optional[str]]: + return pulumi.get(self, "text") + + @property + @pulumi.getter + def to(self) -> pulumi.Output[str]: + return pulumi.get(self, "to") + diff --git a/sdk/python/chronosphereio_chronosphere/gcp_metrics_integration.py b/sdk/python/chronosphereio_chronosphere/gcp_metrics_integration.py new file mode 100644 index 00000000..d8b71fff --- /dev/null +++ b/sdk/python/chronosphereio_chronosphere/gcp_metrics_integration.py @@ -0,0 +1,200 @@ +# coding=utf-8 +# *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import copy +import warnings +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +from . import _utilities +from . import outputs +from ._inputs import * + +__all__ = ['GcpMetricsIntegrationArgs', 'GcpMetricsIntegration'] + +@pulumi.input_type +class GcpMetricsIntegrationArgs: + def __init__(__self__, *, + metric_groups: Optional[pulumi.Input[Sequence[pulumi.Input['GcpMetricsIntegrationMetricGroupArgs']]]] = None, + service_account: Optional[pulumi.Input['GcpMetricsIntegrationServiceAccountArgs']] = None, + slug: Optional[pulumi.Input[str]] = None): + """ + The set of arguments for constructing a GcpMetricsIntegration resource. + """ + if metric_groups is not None: + pulumi.set(__self__, "metric_groups", metric_groups) + if service_account is not None: + pulumi.set(__self__, "service_account", service_account) + if slug is not None: + pulumi.set(__self__, "slug", slug) + + @property + @pulumi.getter(name="metricGroups") + def metric_groups(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['GcpMetricsIntegrationMetricGroupArgs']]]]: + return pulumi.get(self, "metric_groups") + + @metric_groups.setter + def metric_groups(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['GcpMetricsIntegrationMetricGroupArgs']]]]): + pulumi.set(self, "metric_groups", value) + + @property + @pulumi.getter(name="serviceAccount") + def service_account(self) -> Optional[pulumi.Input['GcpMetricsIntegrationServiceAccountArgs']]: + return pulumi.get(self, "service_account") + + @service_account.setter + def service_account(self, value: Optional[pulumi.Input['GcpMetricsIntegrationServiceAccountArgs']]): + pulumi.set(self, "service_account", value) + + @property + @pulumi.getter + def slug(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "slug") + + @slug.setter + def slug(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "slug", value) + + +@pulumi.input_type +class _GcpMetricsIntegrationState: + def __init__(__self__, *, + metric_groups: Optional[pulumi.Input[Sequence[pulumi.Input['GcpMetricsIntegrationMetricGroupArgs']]]] = None, + service_account: Optional[pulumi.Input['GcpMetricsIntegrationServiceAccountArgs']] = None, + slug: Optional[pulumi.Input[str]] = None): + """ + Input properties used for looking up and filtering GcpMetricsIntegration resources. + """ + if metric_groups is not None: + pulumi.set(__self__, "metric_groups", metric_groups) + if service_account is not None: + pulumi.set(__self__, "service_account", service_account) + if slug is not None: + pulumi.set(__self__, "slug", slug) + + @property + @pulumi.getter(name="metricGroups") + def metric_groups(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['GcpMetricsIntegrationMetricGroupArgs']]]]: + return pulumi.get(self, "metric_groups") + + @metric_groups.setter + def metric_groups(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['GcpMetricsIntegrationMetricGroupArgs']]]]): + pulumi.set(self, "metric_groups", value) + + @property + @pulumi.getter(name="serviceAccount") + def service_account(self) -> Optional[pulumi.Input['GcpMetricsIntegrationServiceAccountArgs']]: + return pulumi.get(self, "service_account") + + @service_account.setter + def service_account(self, value: Optional[pulumi.Input['GcpMetricsIntegrationServiceAccountArgs']]): + pulumi.set(self, "service_account", value) + + @property + @pulumi.getter + def slug(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "slug") + + @slug.setter + def slug(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "slug", value) + + +class GcpMetricsIntegration(pulumi.CustomResource): + @overload + def __init__(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + metric_groups: Optional[pulumi.Input[Sequence[pulumi.Input[pulumi.InputType['GcpMetricsIntegrationMetricGroupArgs']]]]] = None, + service_account: Optional[pulumi.Input[pulumi.InputType['GcpMetricsIntegrationServiceAccountArgs']]] = None, + slug: Optional[pulumi.Input[str]] = None, + __props__=None): + """ + Create a GcpMetricsIntegration resource with the given unique name, props, and options. + :param str resource_name: The name of the resource. + :param pulumi.ResourceOptions opts: Options for the resource. + """ + ... + @overload + def __init__(__self__, + resource_name: str, + args: Optional[GcpMetricsIntegrationArgs] = None, + opts: Optional[pulumi.ResourceOptions] = None): + """ + Create a GcpMetricsIntegration resource with the given unique name, props, and options. + :param str resource_name: The name of the resource. + :param GcpMetricsIntegrationArgs 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(GcpMetricsIntegrationArgs, 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, + metric_groups: Optional[pulumi.Input[Sequence[pulumi.Input[pulumi.InputType['GcpMetricsIntegrationMetricGroupArgs']]]]] = None, + service_account: Optional[pulumi.Input[pulumi.InputType['GcpMetricsIntegrationServiceAccountArgs']]] = None, + slug: Optional[pulumi.Input[str]] = None, + __props__=None): + opts = pulumi.ResourceOptions.merge(_utilities.get_resource_opts_defaults(), opts) + if not isinstance(opts, pulumi.ResourceOptions): + raise TypeError('Expected resource options to be a ResourceOptions instance') + if opts.id is None: + if __props__ is not None: + raise TypeError('__props__ is only valid when passed in combination with a valid opts.id to get an existing resource') + __props__ = GcpMetricsIntegrationArgs.__new__(GcpMetricsIntegrationArgs) + + __props__.__dict__["metric_groups"] = metric_groups + __props__.__dict__["service_account"] = service_account + __props__.__dict__["slug"] = slug + super(GcpMetricsIntegration, __self__).__init__( + 'chronosphere:index/gcpMetricsIntegration:GcpMetricsIntegration', + resource_name, + __props__, + opts) + + @staticmethod + def get(resource_name: str, + id: pulumi.Input[str], + opts: Optional[pulumi.ResourceOptions] = None, + metric_groups: Optional[pulumi.Input[Sequence[pulumi.Input[pulumi.InputType['GcpMetricsIntegrationMetricGroupArgs']]]]] = None, + service_account: Optional[pulumi.Input[pulumi.InputType['GcpMetricsIntegrationServiceAccountArgs']]] = None, + slug: Optional[pulumi.Input[str]] = None) -> 'GcpMetricsIntegration': + """ + Get an existing GcpMetricsIntegration 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. + """ + opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id)) + + __props__ = _GcpMetricsIntegrationState.__new__(_GcpMetricsIntegrationState) + + __props__.__dict__["metric_groups"] = metric_groups + __props__.__dict__["service_account"] = service_account + __props__.__dict__["slug"] = slug + return GcpMetricsIntegration(resource_name, opts=opts, __props__=__props__) + + @property + @pulumi.getter(name="metricGroups") + def metric_groups(self) -> pulumi.Output[Optional[Sequence['outputs.GcpMetricsIntegrationMetricGroup']]]: + return pulumi.get(self, "metric_groups") + + @property + @pulumi.getter(name="serviceAccount") + def service_account(self) -> pulumi.Output[Optional['outputs.GcpMetricsIntegrationServiceAccount']]: + return pulumi.get(self, "service_account") + + @property + @pulumi.getter + def slug(self) -> pulumi.Output[Optional[str]]: + return pulumi.get(self, "slug") + diff --git a/sdk/python/chronosphereio_chronosphere/grafana_dashboard.py b/sdk/python/chronosphereio_chronosphere/grafana_dashboard.py new file mode 100644 index 00000000..9a6cbd22 --- /dev/null +++ b/sdk/python/chronosphereio_chronosphere/grafana_dashboard.py @@ -0,0 +1,199 @@ +# coding=utf-8 +# *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import copy +import warnings +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +from . import _utilities + +__all__ = ['GrafanaDashboardArgs', 'GrafanaDashboard'] + +@pulumi.input_type +class GrafanaDashboardArgs: + def __init__(__self__, *, + dashboard_json: pulumi.Input[str], + bucket_id: Optional[pulumi.Input[str]] = None, + collection_id: Optional[pulumi.Input[str]] = None): + """ + The set of arguments for constructing a GrafanaDashboard resource. + """ + pulumi.set(__self__, "dashboard_json", dashboard_json) + if bucket_id is not None: + pulumi.set(__self__, "bucket_id", bucket_id) + if collection_id is not None: + pulumi.set(__self__, "collection_id", collection_id) + + @property + @pulumi.getter(name="dashboardJson") + def dashboard_json(self) -> pulumi.Input[str]: + return pulumi.get(self, "dashboard_json") + + @dashboard_json.setter + def dashboard_json(self, value: pulumi.Input[str]): + pulumi.set(self, "dashboard_json", value) + + @property + @pulumi.getter(name="bucketId") + def bucket_id(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "bucket_id") + + @bucket_id.setter + def bucket_id(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "bucket_id", value) + + @property + @pulumi.getter(name="collectionId") + def collection_id(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "collection_id") + + @collection_id.setter + def collection_id(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "collection_id", value) + + +@pulumi.input_type +class _GrafanaDashboardState: + def __init__(__self__, *, + bucket_id: Optional[pulumi.Input[str]] = None, + collection_id: Optional[pulumi.Input[str]] = None, + dashboard_json: Optional[pulumi.Input[str]] = None): + """ + Input properties used for looking up and filtering GrafanaDashboard resources. + """ + if bucket_id is not None: + pulumi.set(__self__, "bucket_id", bucket_id) + if collection_id is not None: + pulumi.set(__self__, "collection_id", collection_id) + if dashboard_json is not None: + pulumi.set(__self__, "dashboard_json", dashboard_json) + + @property + @pulumi.getter(name="bucketId") + def bucket_id(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "bucket_id") + + @bucket_id.setter + def bucket_id(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "bucket_id", value) + + @property + @pulumi.getter(name="collectionId") + def collection_id(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "collection_id") + + @collection_id.setter + def collection_id(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "collection_id", value) + + @property + @pulumi.getter(name="dashboardJson") + def dashboard_json(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "dashboard_json") + + @dashboard_json.setter + def dashboard_json(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "dashboard_json", value) + + +class GrafanaDashboard(pulumi.CustomResource): + @overload + def __init__(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + bucket_id: Optional[pulumi.Input[str]] = None, + collection_id: Optional[pulumi.Input[str]] = None, + dashboard_json: Optional[pulumi.Input[str]] = None, + __props__=None): + """ + Create a GrafanaDashboard resource with the given unique name, props, and options. + :param str resource_name: The name of the resource. + :param pulumi.ResourceOptions opts: Options for the resource. + """ + ... + @overload + def __init__(__self__, + resource_name: str, + args: GrafanaDashboardArgs, + opts: Optional[pulumi.ResourceOptions] = None): + """ + Create a GrafanaDashboard resource with the given unique name, props, and options. + :param str resource_name: The name of the resource. + :param GrafanaDashboardArgs 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(GrafanaDashboardArgs, 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, + bucket_id: Optional[pulumi.Input[str]] = None, + collection_id: Optional[pulumi.Input[str]] = None, + dashboard_json: Optional[pulumi.Input[str]] = None, + __props__=None): + opts = pulumi.ResourceOptions.merge(_utilities.get_resource_opts_defaults(), opts) + if not isinstance(opts, pulumi.ResourceOptions): + raise TypeError('Expected resource options to be a ResourceOptions instance') + if opts.id is None: + if __props__ is not None: + raise TypeError('__props__ is only valid when passed in combination with a valid opts.id to get an existing resource') + __props__ = GrafanaDashboardArgs.__new__(GrafanaDashboardArgs) + + __props__.__dict__["bucket_id"] = bucket_id + __props__.__dict__["collection_id"] = collection_id + if dashboard_json is None and not opts.urn: + raise TypeError("Missing required property 'dashboard_json'") + __props__.__dict__["dashboard_json"] = dashboard_json + super(GrafanaDashboard, __self__).__init__( + 'chronosphere:index/grafanaDashboard:GrafanaDashboard', + resource_name, + __props__, + opts) + + @staticmethod + def get(resource_name: str, + id: pulumi.Input[str], + opts: Optional[pulumi.ResourceOptions] = None, + bucket_id: Optional[pulumi.Input[str]] = None, + collection_id: Optional[pulumi.Input[str]] = None, + dashboard_json: Optional[pulumi.Input[str]] = None) -> 'GrafanaDashboard': + """ + Get an existing GrafanaDashboard 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. + """ + opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id)) + + __props__ = _GrafanaDashboardState.__new__(_GrafanaDashboardState) + + __props__.__dict__["bucket_id"] = bucket_id + __props__.__dict__["collection_id"] = collection_id + __props__.__dict__["dashboard_json"] = dashboard_json + return GrafanaDashboard(resource_name, opts=opts, __props__=__props__) + + @property + @pulumi.getter(name="bucketId") + def bucket_id(self) -> pulumi.Output[Optional[str]]: + return pulumi.get(self, "bucket_id") + + @property + @pulumi.getter(name="collectionId") + def collection_id(self) -> pulumi.Output[Optional[str]]: + return pulumi.get(self, "collection_id") + + @property + @pulumi.getter(name="dashboardJson") + def dashboard_json(self) -> pulumi.Output[str]: + return pulumi.get(self, "dashboard_json") + diff --git a/sdk/python/chronosphereio_chronosphere/mapping_rule.py b/sdk/python/chronosphereio_chronosphere/mapping_rule.py new file mode 100644 index 00000000..1d9ae16a --- /dev/null +++ b/sdk/python/chronosphereio_chronosphere/mapping_rule.py @@ -0,0 +1,440 @@ +# coding=utf-8 +# *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import copy +import warnings +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +from . import _utilities +from . import outputs +from ._inputs import * + +__all__ = ['MappingRuleArgs', 'MappingRule'] + +@pulumi.input_type +class MappingRuleArgs: + def __init__(__self__, *, + filter: pulumi.Input[str], + name: pulumi.Input[str], + aggregations: Optional[pulumi.Input[str]] = None, + bucket_id: Optional[pulumi.Input[str]] = None, + drop: Optional[pulumi.Input[bool]] = None, + drop_timestamp: Optional[pulumi.Input[bool]] = None, + interval: Optional[pulumi.Input[str]] = None, + mode: Optional[pulumi.Input[str]] = None, + slug: Optional[pulumi.Input[str]] = None, + storage_policy: Optional[pulumi.Input['MappingRuleStoragePolicyArgs']] = None): + """ + The set of arguments for constructing a MappingRule resource. + """ + pulumi.set(__self__, "filter", filter) + pulumi.set(__self__, "name", name) + if aggregations is not None: + pulumi.set(__self__, "aggregations", aggregations) + if bucket_id is not None: + pulumi.set(__self__, "bucket_id", bucket_id) + if drop is not None: + pulumi.set(__self__, "drop", drop) + if drop_timestamp is not None: + pulumi.set(__self__, "drop_timestamp", drop_timestamp) + if interval is not None: + pulumi.set(__self__, "interval", interval) + if mode is not None: + pulumi.set(__self__, "mode", mode) + if slug is not None: + pulumi.set(__self__, "slug", slug) + if storage_policy is not None: + pulumi.set(__self__, "storage_policy", storage_policy) + + @property + @pulumi.getter + def filter(self) -> pulumi.Input[str]: + return pulumi.get(self, "filter") + + @filter.setter + def filter(self, value: pulumi.Input[str]): + pulumi.set(self, "filter", value) + + @property + @pulumi.getter + def name(self) -> pulumi.Input[str]: + return pulumi.get(self, "name") + + @name.setter + def name(self, value: pulumi.Input[str]): + pulumi.set(self, "name", value) + + @property + @pulumi.getter + def aggregations(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "aggregations") + + @aggregations.setter + def aggregations(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "aggregations", value) + + @property + @pulumi.getter(name="bucketId") + def bucket_id(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "bucket_id") + + @bucket_id.setter + def bucket_id(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "bucket_id", value) + + @property + @pulumi.getter + def drop(self) -> Optional[pulumi.Input[bool]]: + return pulumi.get(self, "drop") + + @drop.setter + def drop(self, value: Optional[pulumi.Input[bool]]): + pulumi.set(self, "drop", value) + + @property + @pulumi.getter(name="dropTimestamp") + def drop_timestamp(self) -> Optional[pulumi.Input[bool]]: + return pulumi.get(self, "drop_timestamp") + + @drop_timestamp.setter + def drop_timestamp(self, value: Optional[pulumi.Input[bool]]): + pulumi.set(self, "drop_timestamp", value) + + @property + @pulumi.getter + def interval(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "interval") + + @interval.setter + def interval(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "interval", value) + + @property + @pulumi.getter + def mode(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "mode") + + @mode.setter + def mode(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "mode", value) + + @property + @pulumi.getter + def slug(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "slug") + + @slug.setter + def slug(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "slug", value) + + @property + @pulumi.getter(name="storagePolicy") + def storage_policy(self) -> Optional[pulumi.Input['MappingRuleStoragePolicyArgs']]: + return pulumi.get(self, "storage_policy") + + @storage_policy.setter + def storage_policy(self, value: Optional[pulumi.Input['MappingRuleStoragePolicyArgs']]): + pulumi.set(self, "storage_policy", value) + + +@pulumi.input_type +class _MappingRuleState: + def __init__(__self__, *, + aggregations: Optional[pulumi.Input[str]] = None, + bucket_id: Optional[pulumi.Input[str]] = None, + drop: Optional[pulumi.Input[bool]] = None, + drop_timestamp: Optional[pulumi.Input[bool]] = None, + filter: Optional[pulumi.Input[str]] = None, + interval: Optional[pulumi.Input[str]] = None, + mode: Optional[pulumi.Input[str]] = None, + name: Optional[pulumi.Input[str]] = None, + slug: Optional[pulumi.Input[str]] = None, + storage_policy: Optional[pulumi.Input['MappingRuleStoragePolicyArgs']] = None): + """ + Input properties used for looking up and filtering MappingRule resources. + """ + if aggregations is not None: + pulumi.set(__self__, "aggregations", aggregations) + if bucket_id is not None: + pulumi.set(__self__, "bucket_id", bucket_id) + if drop is not None: + pulumi.set(__self__, "drop", drop) + if drop_timestamp is not None: + pulumi.set(__self__, "drop_timestamp", drop_timestamp) + if filter is not None: + pulumi.set(__self__, "filter", filter) + if interval is not None: + pulumi.set(__self__, "interval", interval) + if mode is not None: + pulumi.set(__self__, "mode", mode) + if name is not None: + pulumi.set(__self__, "name", name) + if slug is not None: + pulumi.set(__self__, "slug", slug) + if storage_policy is not None: + pulumi.set(__self__, "storage_policy", storage_policy) + + @property + @pulumi.getter + def aggregations(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "aggregations") + + @aggregations.setter + def aggregations(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "aggregations", value) + + @property + @pulumi.getter(name="bucketId") + def bucket_id(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "bucket_id") + + @bucket_id.setter + def bucket_id(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "bucket_id", value) + + @property + @pulumi.getter + def drop(self) -> Optional[pulumi.Input[bool]]: + return pulumi.get(self, "drop") + + @drop.setter + def drop(self, value: Optional[pulumi.Input[bool]]): + pulumi.set(self, "drop", value) + + @property + @pulumi.getter(name="dropTimestamp") + def drop_timestamp(self) -> Optional[pulumi.Input[bool]]: + return pulumi.get(self, "drop_timestamp") + + @drop_timestamp.setter + def drop_timestamp(self, value: Optional[pulumi.Input[bool]]): + pulumi.set(self, "drop_timestamp", value) + + @property + @pulumi.getter + def filter(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "filter") + + @filter.setter + def filter(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "filter", value) + + @property + @pulumi.getter + def interval(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "interval") + + @interval.setter + def interval(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "interval", value) + + @property + @pulumi.getter + def mode(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "mode") + + @mode.setter + def mode(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "mode", value) + + @property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "name", value) + + @property + @pulumi.getter + def slug(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "slug") + + @slug.setter + def slug(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "slug", value) + + @property + @pulumi.getter(name="storagePolicy") + def storage_policy(self) -> Optional[pulumi.Input['MappingRuleStoragePolicyArgs']]: + return pulumi.get(self, "storage_policy") + + @storage_policy.setter + def storage_policy(self, value: Optional[pulumi.Input['MappingRuleStoragePolicyArgs']]): + pulumi.set(self, "storage_policy", value) + + +class MappingRule(pulumi.CustomResource): + @overload + def __init__(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + aggregations: Optional[pulumi.Input[str]] = None, + bucket_id: Optional[pulumi.Input[str]] = None, + drop: Optional[pulumi.Input[bool]] = None, + drop_timestamp: Optional[pulumi.Input[bool]] = None, + filter: Optional[pulumi.Input[str]] = None, + interval: Optional[pulumi.Input[str]] = None, + mode: Optional[pulumi.Input[str]] = None, + name: Optional[pulumi.Input[str]] = None, + slug: Optional[pulumi.Input[str]] = None, + storage_policy: Optional[pulumi.Input[pulumi.InputType['MappingRuleStoragePolicyArgs']]] = None, + __props__=None): + """ + Create a MappingRule resource with the given unique name, props, and options. + :param str resource_name: The name of the resource. + :param pulumi.ResourceOptions opts: Options for the resource. + """ + ... + @overload + def __init__(__self__, + resource_name: str, + args: MappingRuleArgs, + opts: Optional[pulumi.ResourceOptions] = None): + """ + Create a MappingRule resource with the given unique name, props, and options. + :param str resource_name: The name of the resource. + :param MappingRuleArgs 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(MappingRuleArgs, 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, + aggregations: Optional[pulumi.Input[str]] = None, + bucket_id: Optional[pulumi.Input[str]] = None, + drop: Optional[pulumi.Input[bool]] = None, + drop_timestamp: Optional[pulumi.Input[bool]] = None, + filter: Optional[pulumi.Input[str]] = None, + interval: Optional[pulumi.Input[str]] = None, + mode: Optional[pulumi.Input[str]] = None, + name: Optional[pulumi.Input[str]] = None, + slug: Optional[pulumi.Input[str]] = None, + storage_policy: Optional[pulumi.Input[pulumi.InputType['MappingRuleStoragePolicyArgs']]] = 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__ = MappingRuleArgs.__new__(MappingRuleArgs) + + __props__.__dict__["aggregations"] = aggregations + __props__.__dict__["bucket_id"] = bucket_id + __props__.__dict__["drop"] = drop + __props__.__dict__["drop_timestamp"] = drop_timestamp + if filter is None and not opts.urn: + raise TypeError("Missing required property 'filter'") + __props__.__dict__["filter"] = filter + __props__.__dict__["interval"] = interval + __props__.__dict__["mode"] = mode + if name is None and not opts.urn: + raise TypeError("Missing required property 'name'") + __props__.__dict__["name"] = name + __props__.__dict__["slug"] = slug + __props__.__dict__["storage_policy"] = storage_policy + super(MappingRule, __self__).__init__( + 'chronosphere:index/mappingRule:MappingRule', + resource_name, + __props__, + opts) + + @staticmethod + def get(resource_name: str, + id: pulumi.Input[str], + opts: Optional[pulumi.ResourceOptions] = None, + aggregations: Optional[pulumi.Input[str]] = None, + bucket_id: Optional[pulumi.Input[str]] = None, + drop: Optional[pulumi.Input[bool]] = None, + drop_timestamp: Optional[pulumi.Input[bool]] = None, + filter: Optional[pulumi.Input[str]] = None, + interval: Optional[pulumi.Input[str]] = None, + mode: Optional[pulumi.Input[str]] = None, + name: Optional[pulumi.Input[str]] = None, + slug: Optional[pulumi.Input[str]] = None, + storage_policy: Optional[pulumi.Input[pulumi.InputType['MappingRuleStoragePolicyArgs']]] = None) -> 'MappingRule': + """ + Get an existing MappingRule 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. + """ + opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id)) + + __props__ = _MappingRuleState.__new__(_MappingRuleState) + + __props__.__dict__["aggregations"] = aggregations + __props__.__dict__["bucket_id"] = bucket_id + __props__.__dict__["drop"] = drop + __props__.__dict__["drop_timestamp"] = drop_timestamp + __props__.__dict__["filter"] = filter + __props__.__dict__["interval"] = interval + __props__.__dict__["mode"] = mode + __props__.__dict__["name"] = name + __props__.__dict__["slug"] = slug + __props__.__dict__["storage_policy"] = storage_policy + return MappingRule(resource_name, opts=opts, __props__=__props__) + + @property + @pulumi.getter + def aggregations(self) -> pulumi.Output[Optional[str]]: + return pulumi.get(self, "aggregations") + + @property + @pulumi.getter(name="bucketId") + def bucket_id(self) -> pulumi.Output[Optional[str]]: + return pulumi.get(self, "bucket_id") + + @property + @pulumi.getter + def drop(self) -> pulumi.Output[Optional[bool]]: + return pulumi.get(self, "drop") + + @property + @pulumi.getter(name="dropTimestamp") + def drop_timestamp(self) -> pulumi.Output[Optional[bool]]: + return pulumi.get(self, "drop_timestamp") + + @property + @pulumi.getter + def filter(self) -> pulumi.Output[str]: + return pulumi.get(self, "filter") + + @property + @pulumi.getter + def interval(self) -> pulumi.Output[Optional[str]]: + return pulumi.get(self, "interval") + + @property + @pulumi.getter + def mode(self) -> pulumi.Output[Optional[str]]: + return pulumi.get(self, "mode") + + @property + @pulumi.getter + def name(self) -> pulumi.Output[str]: + return pulumi.get(self, "name") + + @property + @pulumi.getter + def slug(self) -> pulumi.Output[str]: + return pulumi.get(self, "slug") + + @property + @pulumi.getter(name="storagePolicy") + def storage_policy(self) -> pulumi.Output[Optional['outputs.MappingRuleStoragePolicy']]: + return pulumi.get(self, "storage_policy") + diff --git a/sdk/python/chronosphereio_chronosphere/monitor.py b/sdk/python/chronosphereio_chronosphere/monitor.py new file mode 100644 index 00000000..3862fdf9 --- /dev/null +++ b/sdk/python/chronosphereio_chronosphere/monitor.py @@ -0,0 +1,509 @@ +# coding=utf-8 +# *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import copy +import warnings +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +from . import _utilities +from . import outputs +from ._inputs import * + +__all__ = ['MonitorArgs', 'Monitor'] + +@pulumi.input_type +class MonitorArgs: + def __init__(__self__, *, + name: pulumi.Input[str], + query: pulumi.Input['MonitorQueryArgs'], + series_conditions: pulumi.Input['MonitorSeriesConditionsArgs'], + annotations: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None, + bucket_id: Optional[pulumi.Input[str]] = None, + collection_id: Optional[pulumi.Input[str]] = None, + interval: Optional[pulumi.Input[str]] = None, + labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None, + notification_policy_id: Optional[pulumi.Input[str]] = None, + schedule: Optional[pulumi.Input['MonitorScheduleArgs']] = None, + signal_grouping: Optional[pulumi.Input['MonitorSignalGroupingArgs']] = None, + slug: Optional[pulumi.Input[str]] = None): + """ + The set of arguments for constructing a Monitor resource. + """ + pulumi.set(__self__, "name", name) + pulumi.set(__self__, "query", query) + pulumi.set(__self__, "series_conditions", series_conditions) + if annotations is not None: + pulumi.set(__self__, "annotations", annotations) + if bucket_id is not None: + pulumi.set(__self__, "bucket_id", bucket_id) + if collection_id is not None: + pulumi.set(__self__, "collection_id", collection_id) + if interval is not None: + pulumi.set(__self__, "interval", interval) + if labels is not None: + pulumi.set(__self__, "labels", labels) + if notification_policy_id is not None: + pulumi.set(__self__, "notification_policy_id", notification_policy_id) + if schedule is not None: + pulumi.set(__self__, "schedule", schedule) + if signal_grouping is not None: + pulumi.set(__self__, "signal_grouping", signal_grouping) + if slug is not None: + pulumi.set(__self__, "slug", slug) + + @property + @pulumi.getter + def name(self) -> pulumi.Input[str]: + return pulumi.get(self, "name") + + @name.setter + def name(self, value: pulumi.Input[str]): + pulumi.set(self, "name", value) + + @property + @pulumi.getter + def query(self) -> pulumi.Input['MonitorQueryArgs']: + return pulumi.get(self, "query") + + @query.setter + def query(self, value: pulumi.Input['MonitorQueryArgs']): + pulumi.set(self, "query", value) + + @property + @pulumi.getter(name="seriesConditions") + def series_conditions(self) -> pulumi.Input['MonitorSeriesConditionsArgs']: + return pulumi.get(self, "series_conditions") + + @series_conditions.setter + def series_conditions(self, value: pulumi.Input['MonitorSeriesConditionsArgs']): + pulumi.set(self, "series_conditions", value) + + @property + @pulumi.getter + def annotations(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]: + return pulumi.get(self, "annotations") + + @annotations.setter + def annotations(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]): + pulumi.set(self, "annotations", value) + + @property + @pulumi.getter(name="bucketId") + def bucket_id(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "bucket_id") + + @bucket_id.setter + def bucket_id(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "bucket_id", value) + + @property + @pulumi.getter(name="collectionId") + def collection_id(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "collection_id") + + @collection_id.setter + def collection_id(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "collection_id", value) + + @property + @pulumi.getter + def interval(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "interval") + + @interval.setter + def interval(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "interval", value) + + @property + @pulumi.getter + def labels(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]: + return pulumi.get(self, "labels") + + @labels.setter + def labels(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]): + pulumi.set(self, "labels", value) + + @property + @pulumi.getter(name="notificationPolicyId") + def notification_policy_id(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "notification_policy_id") + + @notification_policy_id.setter + def notification_policy_id(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "notification_policy_id", value) + + @property + @pulumi.getter + def schedule(self) -> Optional[pulumi.Input['MonitorScheduleArgs']]: + return pulumi.get(self, "schedule") + + @schedule.setter + def schedule(self, value: Optional[pulumi.Input['MonitorScheduleArgs']]): + pulumi.set(self, "schedule", value) + + @property + @pulumi.getter(name="signalGrouping") + def signal_grouping(self) -> Optional[pulumi.Input['MonitorSignalGroupingArgs']]: + return pulumi.get(self, "signal_grouping") + + @signal_grouping.setter + def signal_grouping(self, value: Optional[pulumi.Input['MonitorSignalGroupingArgs']]): + pulumi.set(self, "signal_grouping", value) + + @property + @pulumi.getter + def slug(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "slug") + + @slug.setter + def slug(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "slug", value) + + +@pulumi.input_type +class _MonitorState: + def __init__(__self__, *, + annotations: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None, + bucket_id: Optional[pulumi.Input[str]] = None, + collection_id: Optional[pulumi.Input[str]] = None, + interval: Optional[pulumi.Input[str]] = None, + labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None, + name: Optional[pulumi.Input[str]] = None, + notification_policy_id: Optional[pulumi.Input[str]] = None, + query: Optional[pulumi.Input['MonitorQueryArgs']] = None, + schedule: Optional[pulumi.Input['MonitorScheduleArgs']] = None, + series_conditions: Optional[pulumi.Input['MonitorSeriesConditionsArgs']] = None, + signal_grouping: Optional[pulumi.Input['MonitorSignalGroupingArgs']] = None, + slug: Optional[pulumi.Input[str]] = None): + """ + Input properties used for looking up and filtering Monitor resources. + """ + if annotations is not None: + pulumi.set(__self__, "annotations", annotations) + if bucket_id is not None: + pulumi.set(__self__, "bucket_id", bucket_id) + if collection_id is not None: + pulumi.set(__self__, "collection_id", collection_id) + if interval is not None: + pulumi.set(__self__, "interval", interval) + if labels is not None: + pulumi.set(__self__, "labels", labels) + if name is not None: + pulumi.set(__self__, "name", name) + if notification_policy_id is not None: + pulumi.set(__self__, "notification_policy_id", notification_policy_id) + if query is not None: + pulumi.set(__self__, "query", query) + if schedule is not None: + pulumi.set(__self__, "schedule", schedule) + if series_conditions is not None: + pulumi.set(__self__, "series_conditions", series_conditions) + if signal_grouping is not None: + pulumi.set(__self__, "signal_grouping", signal_grouping) + if slug is not None: + pulumi.set(__self__, "slug", slug) + + @property + @pulumi.getter + def annotations(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]: + return pulumi.get(self, "annotations") + + @annotations.setter + def annotations(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]): + pulumi.set(self, "annotations", value) + + @property + @pulumi.getter(name="bucketId") + def bucket_id(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "bucket_id") + + @bucket_id.setter + def bucket_id(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "bucket_id", value) + + @property + @pulumi.getter(name="collectionId") + def collection_id(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "collection_id") + + @collection_id.setter + def collection_id(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "collection_id", value) + + @property + @pulumi.getter + def interval(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "interval") + + @interval.setter + def interval(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "interval", value) + + @property + @pulumi.getter + def labels(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]: + return pulumi.get(self, "labels") + + @labels.setter + def labels(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]): + pulumi.set(self, "labels", value) + + @property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "name", value) + + @property + @pulumi.getter(name="notificationPolicyId") + def notification_policy_id(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "notification_policy_id") + + @notification_policy_id.setter + def notification_policy_id(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "notification_policy_id", value) + + @property + @pulumi.getter + def query(self) -> Optional[pulumi.Input['MonitorQueryArgs']]: + return pulumi.get(self, "query") + + @query.setter + def query(self, value: Optional[pulumi.Input['MonitorQueryArgs']]): + pulumi.set(self, "query", value) + + @property + @pulumi.getter + def schedule(self) -> Optional[pulumi.Input['MonitorScheduleArgs']]: + return pulumi.get(self, "schedule") + + @schedule.setter + def schedule(self, value: Optional[pulumi.Input['MonitorScheduleArgs']]): + pulumi.set(self, "schedule", value) + + @property + @pulumi.getter(name="seriesConditions") + def series_conditions(self) -> Optional[pulumi.Input['MonitorSeriesConditionsArgs']]: + return pulumi.get(self, "series_conditions") + + @series_conditions.setter + def series_conditions(self, value: Optional[pulumi.Input['MonitorSeriesConditionsArgs']]): + pulumi.set(self, "series_conditions", value) + + @property + @pulumi.getter(name="signalGrouping") + def signal_grouping(self) -> Optional[pulumi.Input['MonitorSignalGroupingArgs']]: + return pulumi.get(self, "signal_grouping") + + @signal_grouping.setter + def signal_grouping(self, value: Optional[pulumi.Input['MonitorSignalGroupingArgs']]): + pulumi.set(self, "signal_grouping", value) + + @property + @pulumi.getter + def slug(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "slug") + + @slug.setter + def slug(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "slug", value) + + +class Monitor(pulumi.CustomResource): + @overload + def __init__(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + annotations: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None, + bucket_id: Optional[pulumi.Input[str]] = None, + collection_id: Optional[pulumi.Input[str]] = None, + interval: Optional[pulumi.Input[str]] = None, + labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None, + name: Optional[pulumi.Input[str]] = None, + notification_policy_id: Optional[pulumi.Input[str]] = None, + query: Optional[pulumi.Input[pulumi.InputType['MonitorQueryArgs']]] = None, + schedule: Optional[pulumi.Input[pulumi.InputType['MonitorScheduleArgs']]] = None, + series_conditions: Optional[pulumi.Input[pulumi.InputType['MonitorSeriesConditionsArgs']]] = None, + signal_grouping: Optional[pulumi.Input[pulumi.InputType['MonitorSignalGroupingArgs']]] = None, + slug: Optional[pulumi.Input[str]] = None, + __props__=None): + """ + Create a Monitor resource with the given unique name, props, and options. + :param str resource_name: The name of the resource. + :param pulumi.ResourceOptions opts: Options for the resource. + """ + ... + @overload + def __init__(__self__, + resource_name: str, + args: MonitorArgs, + opts: Optional[pulumi.ResourceOptions] = None): + """ + Create a Monitor resource with the given unique name, props, and options. + :param str resource_name: The name of the resource. + :param MonitorArgs 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(MonitorArgs, 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, + annotations: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None, + bucket_id: Optional[pulumi.Input[str]] = None, + collection_id: Optional[pulumi.Input[str]] = None, + interval: Optional[pulumi.Input[str]] = None, + labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None, + name: Optional[pulumi.Input[str]] = None, + notification_policy_id: Optional[pulumi.Input[str]] = None, + query: Optional[pulumi.Input[pulumi.InputType['MonitorQueryArgs']]] = None, + schedule: Optional[pulumi.Input[pulumi.InputType['MonitorScheduleArgs']]] = None, + series_conditions: Optional[pulumi.Input[pulumi.InputType['MonitorSeriesConditionsArgs']]] = None, + signal_grouping: Optional[pulumi.Input[pulumi.InputType['MonitorSignalGroupingArgs']]] = None, + slug: Optional[pulumi.Input[str]] = None, + __props__=None): + opts = pulumi.ResourceOptions.merge(_utilities.get_resource_opts_defaults(), opts) + if not isinstance(opts, pulumi.ResourceOptions): + raise TypeError('Expected resource options to be a ResourceOptions instance') + if opts.id is None: + if __props__ is not None: + raise TypeError('__props__ is only valid when passed in combination with a valid opts.id to get an existing resource') + __props__ = MonitorArgs.__new__(MonitorArgs) + + __props__.__dict__["annotations"] = annotations + __props__.__dict__["bucket_id"] = bucket_id + __props__.__dict__["collection_id"] = collection_id + __props__.__dict__["interval"] = interval + __props__.__dict__["labels"] = labels + if name is None and not opts.urn: + raise TypeError("Missing required property 'name'") + __props__.__dict__["name"] = name + __props__.__dict__["notification_policy_id"] = notification_policy_id + if query is None and not opts.urn: + raise TypeError("Missing required property 'query'") + __props__.__dict__["query"] = query + __props__.__dict__["schedule"] = schedule + if series_conditions is None and not opts.urn: + raise TypeError("Missing required property 'series_conditions'") + __props__.__dict__["series_conditions"] = series_conditions + __props__.__dict__["signal_grouping"] = signal_grouping + __props__.__dict__["slug"] = slug + super(Monitor, __self__).__init__( + 'chronosphere:index/monitor:Monitor', + resource_name, + __props__, + opts) + + @staticmethod + def get(resource_name: str, + id: pulumi.Input[str], + opts: Optional[pulumi.ResourceOptions] = None, + annotations: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None, + bucket_id: Optional[pulumi.Input[str]] = None, + collection_id: Optional[pulumi.Input[str]] = None, + interval: Optional[pulumi.Input[str]] = None, + labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None, + name: Optional[pulumi.Input[str]] = None, + notification_policy_id: Optional[pulumi.Input[str]] = None, + query: Optional[pulumi.Input[pulumi.InputType['MonitorQueryArgs']]] = None, + schedule: Optional[pulumi.Input[pulumi.InputType['MonitorScheduleArgs']]] = None, + series_conditions: Optional[pulumi.Input[pulumi.InputType['MonitorSeriesConditionsArgs']]] = None, + signal_grouping: Optional[pulumi.Input[pulumi.InputType['MonitorSignalGroupingArgs']]] = None, + slug: Optional[pulumi.Input[str]] = None) -> 'Monitor': + """ + Get an existing Monitor 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. + """ + opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id)) + + __props__ = _MonitorState.__new__(_MonitorState) + + __props__.__dict__["annotations"] = annotations + __props__.__dict__["bucket_id"] = bucket_id + __props__.__dict__["collection_id"] = collection_id + __props__.__dict__["interval"] = interval + __props__.__dict__["labels"] = labels + __props__.__dict__["name"] = name + __props__.__dict__["notification_policy_id"] = notification_policy_id + __props__.__dict__["query"] = query + __props__.__dict__["schedule"] = schedule + __props__.__dict__["series_conditions"] = series_conditions + __props__.__dict__["signal_grouping"] = signal_grouping + __props__.__dict__["slug"] = slug + return Monitor(resource_name, opts=opts, __props__=__props__) + + @property + @pulumi.getter + def annotations(self) -> pulumi.Output[Optional[Mapping[str, str]]]: + return pulumi.get(self, "annotations") + + @property + @pulumi.getter(name="bucketId") + def bucket_id(self) -> pulumi.Output[Optional[str]]: + return pulumi.get(self, "bucket_id") + + @property + @pulumi.getter(name="collectionId") + def collection_id(self) -> pulumi.Output[Optional[str]]: + return pulumi.get(self, "collection_id") + + @property + @pulumi.getter + def interval(self) -> pulumi.Output[Optional[str]]: + return pulumi.get(self, "interval") + + @property + @pulumi.getter + def labels(self) -> pulumi.Output[Optional[Mapping[str, str]]]: + return pulumi.get(self, "labels") + + @property + @pulumi.getter + def name(self) -> pulumi.Output[str]: + return pulumi.get(self, "name") + + @property + @pulumi.getter(name="notificationPolicyId") + def notification_policy_id(self) -> pulumi.Output[Optional[str]]: + return pulumi.get(self, "notification_policy_id") + + @property + @pulumi.getter + def query(self) -> pulumi.Output['outputs.MonitorQuery']: + return pulumi.get(self, "query") + + @property + @pulumi.getter + def schedule(self) -> pulumi.Output[Optional['outputs.MonitorSchedule']]: + return pulumi.get(self, "schedule") + + @property + @pulumi.getter(name="seriesConditions") + def series_conditions(self) -> pulumi.Output['outputs.MonitorSeriesConditions']: + return pulumi.get(self, "series_conditions") + + @property + @pulumi.getter(name="signalGrouping") + def signal_grouping(self) -> pulumi.Output[Optional['outputs.MonitorSignalGrouping']]: + return pulumi.get(self, "signal_grouping") + + @property + @pulumi.getter + def slug(self) -> pulumi.Output[str]: + return pulumi.get(self, "slug") + diff --git a/sdk/python/chronosphereio_chronosphere/notification_policy.py b/sdk/python/chronosphereio_chronosphere/notification_policy.py new file mode 100644 index 00000000..1f3d84c8 --- /dev/null +++ b/sdk/python/chronosphereio_chronosphere/notification_policy.py @@ -0,0 +1,371 @@ +# coding=utf-8 +# *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import copy +import warnings +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +from . import _utilities +from . import outputs +from ._inputs import * + +__all__ = ['NotificationPolicyArgs', 'NotificationPolicy'] + +@pulumi.input_type +class NotificationPolicyArgs: + def __init__(__self__, *, + name: Optional[pulumi.Input[str]] = None, + notification_policy_data: Optional[pulumi.Input[str]] = None, + overrides: Optional[pulumi.Input[Sequence[pulumi.Input['NotificationPolicyOverrideArgs']]]] = None, + routes: Optional[pulumi.Input[Sequence[pulumi.Input['NotificationPolicyRouteArgs']]]] = None, + rules: Optional[pulumi.Input[Sequence[pulumi.Input['NotificationPolicyRuleArgs']]]] = None, + slug: Optional[pulumi.Input[str]] = None, + team_id: Optional[pulumi.Input[str]] = None): + """ + The set of arguments for constructing a NotificationPolicy resource. + """ + if name is not None: + pulumi.set(__self__, "name", name) + if notification_policy_data is not None: + pulumi.set(__self__, "notification_policy_data", notification_policy_data) + if overrides is not None: + pulumi.set(__self__, "overrides", overrides) + if routes is not None: + pulumi.set(__self__, "routes", routes) + if rules is not None: + warnings.warn("""`rule` is deprecated, use `route` instead.""", DeprecationWarning) + pulumi.log.warn("""rules is deprecated: `rule` is deprecated, use `route` instead.""") + if rules is not None: + pulumi.set(__self__, "rules", rules) + if slug is not None: + pulumi.set(__self__, "slug", slug) + if team_id is not None: + pulumi.set(__self__, "team_id", team_id) + + @property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "name", value) + + @property + @pulumi.getter(name="notificationPolicyData") + def notification_policy_data(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "notification_policy_data") + + @notification_policy_data.setter + def notification_policy_data(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "notification_policy_data", value) + + @property + @pulumi.getter + def overrides(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['NotificationPolicyOverrideArgs']]]]: + return pulumi.get(self, "overrides") + + @overrides.setter + def overrides(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['NotificationPolicyOverrideArgs']]]]): + pulumi.set(self, "overrides", value) + + @property + @pulumi.getter + def routes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['NotificationPolicyRouteArgs']]]]: + return pulumi.get(self, "routes") + + @routes.setter + def routes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['NotificationPolicyRouteArgs']]]]): + pulumi.set(self, "routes", value) + + @property + @pulumi.getter + def rules(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['NotificationPolicyRuleArgs']]]]: + warnings.warn("""`rule` is deprecated, use `route` instead.""", DeprecationWarning) + pulumi.log.warn("""rules is deprecated: `rule` is deprecated, use `route` instead.""") + + return pulumi.get(self, "rules") + + @rules.setter + def rules(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['NotificationPolicyRuleArgs']]]]): + pulumi.set(self, "rules", value) + + @property + @pulumi.getter + def slug(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "slug") + + @slug.setter + def slug(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "slug", value) + + @property + @pulumi.getter(name="teamId") + def team_id(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "team_id") + + @team_id.setter + def team_id(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "team_id", value) + + +@pulumi.input_type +class _NotificationPolicyState: + def __init__(__self__, *, + is_independent: Optional[pulumi.Input[bool]] = None, + name: Optional[pulumi.Input[str]] = None, + notification_policy_data: Optional[pulumi.Input[str]] = None, + overrides: Optional[pulumi.Input[Sequence[pulumi.Input['NotificationPolicyOverrideArgs']]]] = None, + routes: Optional[pulumi.Input[Sequence[pulumi.Input['NotificationPolicyRouteArgs']]]] = None, + rules: Optional[pulumi.Input[Sequence[pulumi.Input['NotificationPolicyRuleArgs']]]] = None, + slug: Optional[pulumi.Input[str]] = None, + team_id: Optional[pulumi.Input[str]] = None): + """ + Input properties used for looking up and filtering NotificationPolicy resources. + """ + if is_independent is not None: + pulumi.set(__self__, "is_independent", is_independent) + if name is not None: + pulumi.set(__self__, "name", name) + if notification_policy_data is not None: + pulumi.set(__self__, "notification_policy_data", notification_policy_data) + if overrides is not None: + pulumi.set(__self__, "overrides", overrides) + if routes is not None: + pulumi.set(__self__, "routes", routes) + if rules is not None: + warnings.warn("""`rule` is deprecated, use `route` instead.""", DeprecationWarning) + pulumi.log.warn("""rules is deprecated: `rule` is deprecated, use `route` instead.""") + if rules is not None: + pulumi.set(__self__, "rules", rules) + if slug is not None: + pulumi.set(__self__, "slug", slug) + if team_id is not None: + pulumi.set(__self__, "team_id", team_id) + + @property + @pulumi.getter(name="isIndependent") + def is_independent(self) -> Optional[pulumi.Input[bool]]: + return pulumi.get(self, "is_independent") + + @is_independent.setter + def is_independent(self, value: Optional[pulumi.Input[bool]]): + pulumi.set(self, "is_independent", value) + + @property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "name", value) + + @property + @pulumi.getter(name="notificationPolicyData") + def notification_policy_data(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "notification_policy_data") + + @notification_policy_data.setter + def notification_policy_data(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "notification_policy_data", value) + + @property + @pulumi.getter + def overrides(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['NotificationPolicyOverrideArgs']]]]: + return pulumi.get(self, "overrides") + + @overrides.setter + def overrides(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['NotificationPolicyOverrideArgs']]]]): + pulumi.set(self, "overrides", value) + + @property + @pulumi.getter + def routes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['NotificationPolicyRouteArgs']]]]: + return pulumi.get(self, "routes") + + @routes.setter + def routes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['NotificationPolicyRouteArgs']]]]): + pulumi.set(self, "routes", value) + + @property + @pulumi.getter + def rules(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['NotificationPolicyRuleArgs']]]]: + warnings.warn("""`rule` is deprecated, use `route` instead.""", DeprecationWarning) + pulumi.log.warn("""rules is deprecated: `rule` is deprecated, use `route` instead.""") + + return pulumi.get(self, "rules") + + @rules.setter + def rules(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['NotificationPolicyRuleArgs']]]]): + pulumi.set(self, "rules", value) + + @property + @pulumi.getter + def slug(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "slug") + + @slug.setter + def slug(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "slug", value) + + @property + @pulumi.getter(name="teamId") + def team_id(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "team_id") + + @team_id.setter + def team_id(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "team_id", value) + + +class NotificationPolicy(pulumi.CustomResource): + @overload + def __init__(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + name: Optional[pulumi.Input[str]] = None, + notification_policy_data: Optional[pulumi.Input[str]] = None, + overrides: Optional[pulumi.Input[Sequence[pulumi.Input[pulumi.InputType['NotificationPolicyOverrideArgs']]]]] = None, + routes: Optional[pulumi.Input[Sequence[pulumi.Input[pulumi.InputType['NotificationPolicyRouteArgs']]]]] = None, + rules: Optional[pulumi.Input[Sequence[pulumi.Input[pulumi.InputType['NotificationPolicyRuleArgs']]]]] = None, + slug: Optional[pulumi.Input[str]] = None, + team_id: Optional[pulumi.Input[str]] = None, + __props__=None): + """ + Create a NotificationPolicy resource with the given unique name, props, and options. + :param str resource_name: The name of the resource. + :param pulumi.ResourceOptions opts: Options for the resource. + """ + ... + @overload + def __init__(__self__, + resource_name: str, + args: Optional[NotificationPolicyArgs] = None, + opts: Optional[pulumi.ResourceOptions] = None): + """ + Create a NotificationPolicy resource with the given unique name, props, and options. + :param str resource_name: The name of the resource. + :param NotificationPolicyArgs 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(NotificationPolicyArgs, 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[str]] = None, + notification_policy_data: Optional[pulumi.Input[str]] = None, + overrides: Optional[pulumi.Input[Sequence[pulumi.Input[pulumi.InputType['NotificationPolicyOverrideArgs']]]]] = None, + routes: Optional[pulumi.Input[Sequence[pulumi.Input[pulumi.InputType['NotificationPolicyRouteArgs']]]]] = None, + rules: Optional[pulumi.Input[Sequence[pulumi.Input[pulumi.InputType['NotificationPolicyRuleArgs']]]]] = None, + slug: Optional[pulumi.Input[str]] = None, + team_id: Optional[pulumi.Input[str]] = None, + __props__=None): + opts = pulumi.ResourceOptions.merge(_utilities.get_resource_opts_defaults(), opts) + if not isinstance(opts, pulumi.ResourceOptions): + raise TypeError('Expected resource options to be a ResourceOptions instance') + if opts.id is None: + if __props__ is not None: + raise TypeError('__props__ is only valid when passed in combination with a valid opts.id to get an existing resource') + __props__ = NotificationPolicyArgs.__new__(NotificationPolicyArgs) + + __props__.__dict__["name"] = name + __props__.__dict__["notification_policy_data"] = notification_policy_data + __props__.__dict__["overrides"] = overrides + __props__.__dict__["routes"] = routes + __props__.__dict__["rules"] = rules + __props__.__dict__["slug"] = slug + __props__.__dict__["team_id"] = team_id + __props__.__dict__["is_independent"] = None + super(NotificationPolicy, __self__).__init__( + 'chronosphere:index/notificationPolicy:NotificationPolicy', + resource_name, + __props__, + opts) + + @staticmethod + def get(resource_name: str, + id: pulumi.Input[str], + opts: Optional[pulumi.ResourceOptions] = None, + is_independent: Optional[pulumi.Input[bool]] = None, + name: Optional[pulumi.Input[str]] = None, + notification_policy_data: Optional[pulumi.Input[str]] = None, + overrides: Optional[pulumi.Input[Sequence[pulumi.Input[pulumi.InputType['NotificationPolicyOverrideArgs']]]]] = None, + routes: Optional[pulumi.Input[Sequence[pulumi.Input[pulumi.InputType['NotificationPolicyRouteArgs']]]]] = None, + rules: Optional[pulumi.Input[Sequence[pulumi.Input[pulumi.InputType['NotificationPolicyRuleArgs']]]]] = None, + slug: Optional[pulumi.Input[str]] = None, + team_id: Optional[pulumi.Input[str]] = None) -> 'NotificationPolicy': + """ + Get an existing NotificationPolicy 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. + """ + opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id)) + + __props__ = _NotificationPolicyState.__new__(_NotificationPolicyState) + + __props__.__dict__["is_independent"] = is_independent + __props__.__dict__["name"] = name + __props__.__dict__["notification_policy_data"] = notification_policy_data + __props__.__dict__["overrides"] = overrides + __props__.__dict__["routes"] = routes + __props__.__dict__["rules"] = rules + __props__.__dict__["slug"] = slug + __props__.__dict__["team_id"] = team_id + return NotificationPolicy(resource_name, opts=opts, __props__=__props__) + + @property + @pulumi.getter(name="isIndependent") + def is_independent(self) -> pulumi.Output[bool]: + return pulumi.get(self, "is_independent") + + @property + @pulumi.getter + def name(self) -> pulumi.Output[Optional[str]]: + return pulumi.get(self, "name") + + @property + @pulumi.getter(name="notificationPolicyData") + def notification_policy_data(self) -> pulumi.Output[str]: + return pulumi.get(self, "notification_policy_data") + + @property + @pulumi.getter + def overrides(self) -> pulumi.Output[Optional[Sequence['outputs.NotificationPolicyOverride']]]: + return pulumi.get(self, "overrides") + + @property + @pulumi.getter + def routes(self) -> pulumi.Output[Optional[Sequence['outputs.NotificationPolicyRoute']]]: + return pulumi.get(self, "routes") + + @property + @pulumi.getter + def rules(self) -> pulumi.Output[Optional[Sequence['outputs.NotificationPolicyRule']]]: + warnings.warn("""`rule` is deprecated, use `route` instead.""", DeprecationWarning) + pulumi.log.warn("""rules is deprecated: `rule` is deprecated, use `route` instead.""") + + return pulumi.get(self, "rules") + + @property + @pulumi.getter + def slug(self) -> pulumi.Output[str]: + return pulumi.get(self, "slug") + + @property + @pulumi.getter(name="teamId") + def team_id(self) -> pulumi.Output[Optional[str]]: + return pulumi.get(self, "team_id") + diff --git a/sdk/python/chronosphereio_chronosphere/notification_policy_data_source.py b/sdk/python/chronosphereio_chronosphere/notification_policy_data_source.py new file mode 100644 index 00000000..aca3eb8b --- /dev/null +++ b/sdk/python/chronosphereio_chronosphere/notification_policy_data_source.py @@ -0,0 +1,170 @@ +# coding=utf-8 +# *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import copy +import warnings +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +from . import _utilities +from . import outputs +from ._inputs import * + +__all__ = [ + 'NotificationPolicyDataSourceResult', + 'AwaitableNotificationPolicyDataSourceResult', + 'notification_policy_data_source', + 'notification_policy_data_source_output', +] + +@pulumi.output_type +class NotificationPolicyDataSourceResult: + """ + A collection of values returned by NotificationPolicyDataSource. + """ + def __init__(__self__, id=None, is_independent=None, name=None, notification_policy_data=None, overrides=None, routes=None, rules=None, slug=None, team_id=None): + if id and not isinstance(id, str): + raise TypeError("Expected argument 'id' to be a str") + pulumi.set(__self__, "id", id) + if is_independent and not isinstance(is_independent, bool): + raise TypeError("Expected argument 'is_independent' to be a bool") + pulumi.set(__self__, "is_independent", is_independent) + if name and not isinstance(name, str): + raise TypeError("Expected argument 'name' to be a str") + pulumi.set(__self__, "name", name) + if notification_policy_data and not isinstance(notification_policy_data, str): + raise TypeError("Expected argument 'notification_policy_data' to be a str") + pulumi.set(__self__, "notification_policy_data", notification_policy_data) + if overrides and not isinstance(overrides, list): + raise TypeError("Expected argument 'overrides' to be a list") + pulumi.set(__self__, "overrides", overrides) + if routes and not isinstance(routes, list): + raise TypeError("Expected argument 'routes' to be a list") + pulumi.set(__self__, "routes", routes) + if rules and not isinstance(rules, list): + raise TypeError("Expected argument 'rules' to be a list") + pulumi.set(__self__, "rules", rules) + if slug and not isinstance(slug, str): + raise TypeError("Expected argument 'slug' to be a str") + pulumi.set(__self__, "slug", slug) + if team_id and not isinstance(team_id, str): + raise TypeError("Expected argument 'team_id' to be a str") + pulumi.set(__self__, "team_id", team_id) + + @property + @pulumi.getter + def id(self) -> str: + """ + The provider-assigned unique ID for this managed resource. + """ + return pulumi.get(self, "id") + + @property + @pulumi.getter(name="isIndependent") + def is_independent(self) -> bool: + return pulumi.get(self, "is_independent") + + @property + @pulumi.getter + def name(self) -> Optional[str]: + return pulumi.get(self, "name") + + @property + @pulumi.getter(name="notificationPolicyData") + def notification_policy_data(self) -> str: + return pulumi.get(self, "notification_policy_data") + + @property + @pulumi.getter + def overrides(self) -> Optional[Sequence['outputs.NotificationPolicyDataSourceOverrideResult']]: + return pulumi.get(self, "overrides") + + @property + @pulumi.getter + def routes(self) -> Optional[Sequence['outputs.NotificationPolicyDataSourceRouteResult']]: + return pulumi.get(self, "routes") + + @property + @pulumi.getter + def rules(self) -> Optional[Sequence['outputs.NotificationPolicyDataSourceRuleResult']]: + warnings.warn("""`rule` is deprecated, use `route` instead.""", DeprecationWarning) + pulumi.log.warn("""rules is deprecated: `rule` is deprecated, use `route` instead.""") + + return pulumi.get(self, "rules") + + @property + @pulumi.getter + def slug(self) -> str: + return pulumi.get(self, "slug") + + @property + @pulumi.getter(name="teamId") + def team_id(self) -> Optional[str]: + return pulumi.get(self, "team_id") + + +class AwaitableNotificationPolicyDataSourceResult(NotificationPolicyDataSourceResult): + # pylint: disable=using-constant-test + def __await__(self): + if False: + yield self + return NotificationPolicyDataSourceResult( + id=self.id, + is_independent=self.is_independent, + name=self.name, + notification_policy_data=self.notification_policy_data, + overrides=self.overrides, + routes=self.routes, + rules=self.rules, + slug=self.slug, + team_id=self.team_id) + + +def notification_policy_data_source(name: Optional[str] = None, + notification_policy_data: Optional[str] = None, + overrides: Optional[Sequence[pulumi.InputType['NotificationPolicyDataSourceOverrideArgs']]] = None, + routes: Optional[Sequence[pulumi.InputType['NotificationPolicyDataSourceRouteArgs']]] = None, + rules: Optional[Sequence[pulumi.InputType['NotificationPolicyDataSourceRuleArgs']]] = None, + slug: Optional[str] = None, + team_id: Optional[str] = None, + opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableNotificationPolicyDataSourceResult: + """ + Use this data source to access information about an existing resource. + """ + __args__ = dict() + __args__['name'] = name + __args__['notificationPolicyData'] = notification_policy_data + __args__['overrides'] = overrides + __args__['routes'] = routes + __args__['rules'] = rules + __args__['slug'] = slug + __args__['teamId'] = team_id + opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke('chronosphere:index/notificationPolicyDataSource:NotificationPolicyDataSource', __args__, opts=opts, typ=NotificationPolicyDataSourceResult).value + + return AwaitableNotificationPolicyDataSourceResult( + id=pulumi.get(__ret__, 'id'), + is_independent=pulumi.get(__ret__, 'is_independent'), + name=pulumi.get(__ret__, 'name'), + notification_policy_data=pulumi.get(__ret__, 'notification_policy_data'), + overrides=pulumi.get(__ret__, 'overrides'), + routes=pulumi.get(__ret__, 'routes'), + rules=pulumi.get(__ret__, 'rules'), + slug=pulumi.get(__ret__, 'slug'), + team_id=pulumi.get(__ret__, 'team_id')) + + +@_utilities.lift_output_func(notification_policy_data_source) +def notification_policy_data_source_output(name: Optional[pulumi.Input[Optional[str]]] = None, + notification_policy_data: Optional[pulumi.Input[Optional[str]]] = None, + overrides: Optional[pulumi.Input[Optional[Sequence[pulumi.InputType['NotificationPolicyDataSourceOverrideArgs']]]]] = None, + routes: Optional[pulumi.Input[Optional[Sequence[pulumi.InputType['NotificationPolicyDataSourceRouteArgs']]]]] = None, + rules: Optional[pulumi.Input[Optional[Sequence[pulumi.InputType['NotificationPolicyDataSourceRuleArgs']]]]] = None, + slug: Optional[pulumi.Input[Optional[str]]] = None, + team_id: Optional[pulumi.Input[Optional[str]]] = None, + opts: Optional[pulumi.InvokeOptions] = None) -> pulumi.Output[NotificationPolicyDataSourceResult]: + """ + Use this data source to access information about an existing resource. + """ + ... diff --git a/sdk/python/chronosphereio_chronosphere/opsgenie_alert_notifier.py b/sdk/python/chronosphereio_chronosphere/opsgenie_alert_notifier.py new file mode 100644 index 00000000..99e8af14 --- /dev/null +++ b/sdk/python/chronosphereio_chronosphere/opsgenie_alert_notifier.py @@ -0,0 +1,714 @@ +# coding=utf-8 +# *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import copy +import warnings +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +from . import _utilities +from . import outputs +from ._inputs import * + +__all__ = ['OpsgenieAlertNotifierArgs', 'OpsgenieAlertNotifier'] + +@pulumi.input_type +class OpsgenieAlertNotifierArgs: + def __init__(__self__, *, + api_key: pulumi.Input[str], + name: pulumi.Input[str], + api_url: Optional[pulumi.Input[str]] = None, + basic_auth_password: Optional[pulumi.Input[str]] = None, + basic_auth_username: Optional[pulumi.Input[str]] = None, + bearer_token: Optional[pulumi.Input[str]] = None, + description: Optional[pulumi.Input[str]] = None, + details: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None, + message: Optional[pulumi.Input[str]] = None, + note: Optional[pulumi.Input[str]] = None, + priority: Optional[pulumi.Input[str]] = None, + proxy_url: Optional[pulumi.Input[str]] = None, + responders: Optional[pulumi.Input[Sequence[pulumi.Input['OpsgenieAlertNotifierResponderArgs']]]] = None, + send_resolved: Optional[pulumi.Input[bool]] = None, + slug: Optional[pulumi.Input[str]] = None, + source: Optional[pulumi.Input[str]] = None, + tags: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None, + tls_insecure_skip_verify: Optional[pulumi.Input[bool]] = None): + """ + The set of arguments for constructing a OpsgenieAlertNotifier resource. + """ + pulumi.set(__self__, "api_key", api_key) + pulumi.set(__self__, "name", name) + if api_url is not None: + pulumi.set(__self__, "api_url", api_url) + if basic_auth_password is not None: + pulumi.set(__self__, "basic_auth_password", basic_auth_password) + if basic_auth_username is not None: + pulumi.set(__self__, "basic_auth_username", basic_auth_username) + if bearer_token is not None: + pulumi.set(__self__, "bearer_token", bearer_token) + if description is not None: + pulumi.set(__self__, "description", description) + if details is not None: + pulumi.set(__self__, "details", details) + if message is not None: + pulumi.set(__self__, "message", message) + if note is not None: + pulumi.set(__self__, "note", note) + if priority is not None: + pulumi.set(__self__, "priority", priority) + if proxy_url is not None: + pulumi.set(__self__, "proxy_url", proxy_url) + if responders is not None: + pulumi.set(__self__, "responders", responders) + if send_resolved is not None: + pulumi.set(__self__, "send_resolved", send_resolved) + if slug is not None: + pulumi.set(__self__, "slug", slug) + if source is not None: + pulumi.set(__self__, "source", source) + if tags is not None: + pulumi.set(__self__, "tags", tags) + if tls_insecure_skip_verify is not None: + pulumi.set(__self__, "tls_insecure_skip_verify", tls_insecure_skip_verify) + + @property + @pulumi.getter(name="apiKey") + def api_key(self) -> pulumi.Input[str]: + return pulumi.get(self, "api_key") + + @api_key.setter + def api_key(self, value: pulumi.Input[str]): + pulumi.set(self, "api_key", value) + + @property + @pulumi.getter + def name(self) -> pulumi.Input[str]: + return pulumi.get(self, "name") + + @name.setter + def name(self, value: pulumi.Input[str]): + pulumi.set(self, "name", value) + + @property + @pulumi.getter(name="apiUrl") + def api_url(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "api_url") + + @api_url.setter + def api_url(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "api_url", value) + + @property + @pulumi.getter(name="basicAuthPassword") + def basic_auth_password(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "basic_auth_password") + + @basic_auth_password.setter + def basic_auth_password(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "basic_auth_password", value) + + @property + @pulumi.getter(name="basicAuthUsername") + def basic_auth_username(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "basic_auth_username") + + @basic_auth_username.setter + def basic_auth_username(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "basic_auth_username", value) + + @property + @pulumi.getter(name="bearerToken") + def bearer_token(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "bearer_token") + + @bearer_token.setter + def bearer_token(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "bearer_token", value) + + @property + @pulumi.getter + def description(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "description") + + @description.setter + def description(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "description", value) + + @property + @pulumi.getter + def details(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]: + return pulumi.get(self, "details") + + @details.setter + def details(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]): + pulumi.set(self, "details", value) + + @property + @pulumi.getter + def message(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "message") + + @message.setter + def message(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "message", value) + + @property + @pulumi.getter + def note(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "note") + + @note.setter + def note(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "note", value) + + @property + @pulumi.getter + def priority(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "priority") + + @priority.setter + def priority(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "priority", value) + + @property + @pulumi.getter(name="proxyUrl") + def proxy_url(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "proxy_url") + + @proxy_url.setter + def proxy_url(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "proxy_url", value) + + @property + @pulumi.getter + def responders(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['OpsgenieAlertNotifierResponderArgs']]]]: + return pulumi.get(self, "responders") + + @responders.setter + def responders(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['OpsgenieAlertNotifierResponderArgs']]]]): + pulumi.set(self, "responders", value) + + @property + @pulumi.getter(name="sendResolved") + def send_resolved(self) -> Optional[pulumi.Input[bool]]: + return pulumi.get(self, "send_resolved") + + @send_resolved.setter + def send_resolved(self, value: Optional[pulumi.Input[bool]]): + pulumi.set(self, "send_resolved", value) + + @property + @pulumi.getter + def slug(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "slug") + + @slug.setter + def slug(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "slug", value) + + @property + @pulumi.getter + def source(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "source") + + @source.setter + def source(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "source", value) + + @property + @pulumi.getter + def tags(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]: + return pulumi.get(self, "tags") + + @tags.setter + def tags(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]): + pulumi.set(self, "tags", value) + + @property + @pulumi.getter(name="tlsInsecureSkipVerify") + def tls_insecure_skip_verify(self) -> Optional[pulumi.Input[bool]]: + return pulumi.get(self, "tls_insecure_skip_verify") + + @tls_insecure_skip_verify.setter + def tls_insecure_skip_verify(self, value: Optional[pulumi.Input[bool]]): + pulumi.set(self, "tls_insecure_skip_verify", value) + + +@pulumi.input_type +class _OpsgenieAlertNotifierState: + def __init__(__self__, *, + api_key: Optional[pulumi.Input[str]] = None, + api_url: Optional[pulumi.Input[str]] = None, + basic_auth_password: Optional[pulumi.Input[str]] = None, + basic_auth_username: Optional[pulumi.Input[str]] = None, + bearer_token: Optional[pulumi.Input[str]] = None, + description: Optional[pulumi.Input[str]] = None, + details: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None, + message: Optional[pulumi.Input[str]] = None, + name: Optional[pulumi.Input[str]] = None, + note: Optional[pulumi.Input[str]] = None, + priority: Optional[pulumi.Input[str]] = None, + proxy_url: Optional[pulumi.Input[str]] = None, + responders: Optional[pulumi.Input[Sequence[pulumi.Input['OpsgenieAlertNotifierResponderArgs']]]] = None, + send_resolved: Optional[pulumi.Input[bool]] = None, + slug: Optional[pulumi.Input[str]] = None, + source: Optional[pulumi.Input[str]] = None, + tags: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None, + tls_insecure_skip_verify: Optional[pulumi.Input[bool]] = None): + """ + Input properties used for looking up and filtering OpsgenieAlertNotifier resources. + """ + 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 basic_auth_password is not None: + pulumi.set(__self__, "basic_auth_password", basic_auth_password) + if basic_auth_username is not None: + pulumi.set(__self__, "basic_auth_username", basic_auth_username) + if bearer_token is not None: + pulumi.set(__self__, "bearer_token", bearer_token) + if description is not None: + pulumi.set(__self__, "description", description) + if details is not None: + pulumi.set(__self__, "details", details) + if message is not None: + pulumi.set(__self__, "message", message) + if name is not None: + pulumi.set(__self__, "name", name) + if note is not None: + pulumi.set(__self__, "note", note) + if priority is not None: + pulumi.set(__self__, "priority", priority) + if proxy_url is not None: + pulumi.set(__self__, "proxy_url", proxy_url) + if responders is not None: + pulumi.set(__self__, "responders", responders) + if send_resolved is not None: + pulumi.set(__self__, "send_resolved", send_resolved) + if slug is not None: + pulumi.set(__self__, "slug", slug) + if source is not None: + pulumi.set(__self__, "source", source) + if tags is not None: + pulumi.set(__self__, "tags", tags) + if tls_insecure_skip_verify is not None: + pulumi.set(__self__, "tls_insecure_skip_verify", tls_insecure_skip_verify) + + @property + @pulumi.getter(name="apiKey") + def api_key(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "api_key") + + @api_key.setter + def api_key(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "api_key", value) + + @property + @pulumi.getter(name="apiUrl") + def api_url(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "api_url") + + @api_url.setter + def api_url(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "api_url", value) + + @property + @pulumi.getter(name="basicAuthPassword") + def basic_auth_password(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "basic_auth_password") + + @basic_auth_password.setter + def basic_auth_password(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "basic_auth_password", value) + + @property + @pulumi.getter(name="basicAuthUsername") + def basic_auth_username(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "basic_auth_username") + + @basic_auth_username.setter + def basic_auth_username(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "basic_auth_username", value) + + @property + @pulumi.getter(name="bearerToken") + def bearer_token(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "bearer_token") + + @bearer_token.setter + def bearer_token(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "bearer_token", value) + + @property + @pulumi.getter + def description(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "description") + + @description.setter + def description(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "description", value) + + @property + @pulumi.getter + def details(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]: + return pulumi.get(self, "details") + + @details.setter + def details(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]): + pulumi.set(self, "details", value) + + @property + @pulumi.getter + def message(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "message") + + @message.setter + def message(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "message", value) + + @property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "name", value) + + @property + @pulumi.getter + def note(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "note") + + @note.setter + def note(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "note", value) + + @property + @pulumi.getter + def priority(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "priority") + + @priority.setter + def priority(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "priority", value) + + @property + @pulumi.getter(name="proxyUrl") + def proxy_url(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "proxy_url") + + @proxy_url.setter + def proxy_url(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "proxy_url", value) + + @property + @pulumi.getter + def responders(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['OpsgenieAlertNotifierResponderArgs']]]]: + return pulumi.get(self, "responders") + + @responders.setter + def responders(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['OpsgenieAlertNotifierResponderArgs']]]]): + pulumi.set(self, "responders", value) + + @property + @pulumi.getter(name="sendResolved") + def send_resolved(self) -> Optional[pulumi.Input[bool]]: + return pulumi.get(self, "send_resolved") + + @send_resolved.setter + def send_resolved(self, value: Optional[pulumi.Input[bool]]): + pulumi.set(self, "send_resolved", value) + + @property + @pulumi.getter + def slug(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "slug") + + @slug.setter + def slug(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "slug", value) + + @property + @pulumi.getter + def source(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "source") + + @source.setter + def source(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "source", value) + + @property + @pulumi.getter + def tags(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]: + return pulumi.get(self, "tags") + + @tags.setter + def tags(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]): + pulumi.set(self, "tags", value) + + @property + @pulumi.getter(name="tlsInsecureSkipVerify") + def tls_insecure_skip_verify(self) -> Optional[pulumi.Input[bool]]: + return pulumi.get(self, "tls_insecure_skip_verify") + + @tls_insecure_skip_verify.setter + def tls_insecure_skip_verify(self, value: Optional[pulumi.Input[bool]]): + pulumi.set(self, "tls_insecure_skip_verify", value) + + +class OpsgenieAlertNotifier(pulumi.CustomResource): + @overload + def __init__(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + api_key: Optional[pulumi.Input[str]] = None, + api_url: Optional[pulumi.Input[str]] = None, + basic_auth_password: Optional[pulumi.Input[str]] = None, + basic_auth_username: Optional[pulumi.Input[str]] = None, + bearer_token: Optional[pulumi.Input[str]] = None, + description: Optional[pulumi.Input[str]] = None, + details: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None, + message: Optional[pulumi.Input[str]] = None, + name: Optional[pulumi.Input[str]] = None, + note: Optional[pulumi.Input[str]] = None, + priority: Optional[pulumi.Input[str]] = None, + proxy_url: Optional[pulumi.Input[str]] = None, + responders: Optional[pulumi.Input[Sequence[pulumi.Input[pulumi.InputType['OpsgenieAlertNotifierResponderArgs']]]]] = None, + send_resolved: Optional[pulumi.Input[bool]] = None, + slug: Optional[pulumi.Input[str]] = None, + source: Optional[pulumi.Input[str]] = None, + tags: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None, + tls_insecure_skip_verify: Optional[pulumi.Input[bool]] = None, + __props__=None): + """ + Create a OpsgenieAlertNotifier resource with the given unique name, props, and options. + :param str resource_name: The name of the resource. + :param pulumi.ResourceOptions opts: Options for the resource. + """ + ... + @overload + def __init__(__self__, + resource_name: str, + args: OpsgenieAlertNotifierArgs, + opts: Optional[pulumi.ResourceOptions] = None): + """ + Create a OpsgenieAlertNotifier resource with the given unique name, props, and options. + :param str resource_name: The name of the resource. + :param OpsgenieAlertNotifierArgs 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(OpsgenieAlertNotifierArgs, 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, + api_key: Optional[pulumi.Input[str]] = None, + api_url: Optional[pulumi.Input[str]] = None, + basic_auth_password: Optional[pulumi.Input[str]] = None, + basic_auth_username: Optional[pulumi.Input[str]] = None, + bearer_token: Optional[pulumi.Input[str]] = None, + description: Optional[pulumi.Input[str]] = None, + details: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None, + message: Optional[pulumi.Input[str]] = None, + name: Optional[pulumi.Input[str]] = None, + note: Optional[pulumi.Input[str]] = None, + priority: Optional[pulumi.Input[str]] = None, + proxy_url: Optional[pulumi.Input[str]] = None, + responders: Optional[pulumi.Input[Sequence[pulumi.Input[pulumi.InputType['OpsgenieAlertNotifierResponderArgs']]]]] = None, + send_resolved: Optional[pulumi.Input[bool]] = None, + slug: Optional[pulumi.Input[str]] = None, + source: Optional[pulumi.Input[str]] = None, + tags: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None, + tls_insecure_skip_verify: Optional[pulumi.Input[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__ = OpsgenieAlertNotifierArgs.__new__(OpsgenieAlertNotifierArgs) + + if api_key is None and not opts.urn: + raise TypeError("Missing required property 'api_key'") + __props__.__dict__["api_key"] = None if api_key is None else pulumi.Output.secret(api_key) + __props__.__dict__["api_url"] = api_url + __props__.__dict__["basic_auth_password"] = None if basic_auth_password is None else pulumi.Output.secret(basic_auth_password) + __props__.__dict__["basic_auth_username"] = basic_auth_username + __props__.__dict__["bearer_token"] = bearer_token + __props__.__dict__["description"] = description + __props__.__dict__["details"] = details + __props__.__dict__["message"] = message + if name is None and not opts.urn: + raise TypeError("Missing required property 'name'") + __props__.__dict__["name"] = name + __props__.__dict__["note"] = note + __props__.__dict__["priority"] = priority + __props__.__dict__["proxy_url"] = proxy_url + __props__.__dict__["responders"] = responders + __props__.__dict__["send_resolved"] = send_resolved + __props__.__dict__["slug"] = slug + __props__.__dict__["source"] = source + __props__.__dict__["tags"] = tags + __props__.__dict__["tls_insecure_skip_verify"] = tls_insecure_skip_verify + secret_opts = pulumi.ResourceOptions(additional_secret_outputs=["apiKey", "basicAuthPassword"]) + opts = pulumi.ResourceOptions.merge(opts, secret_opts) + super(OpsgenieAlertNotifier, __self__).__init__( + 'chronosphere:index/opsgenieAlertNotifier:OpsgenieAlertNotifier', + resource_name, + __props__, + opts) + + @staticmethod + def get(resource_name: str, + id: pulumi.Input[str], + opts: Optional[pulumi.ResourceOptions] = None, + api_key: Optional[pulumi.Input[str]] = None, + api_url: Optional[pulumi.Input[str]] = None, + basic_auth_password: Optional[pulumi.Input[str]] = None, + basic_auth_username: Optional[pulumi.Input[str]] = None, + bearer_token: Optional[pulumi.Input[str]] = None, + description: Optional[pulumi.Input[str]] = None, + details: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None, + message: Optional[pulumi.Input[str]] = None, + name: Optional[pulumi.Input[str]] = None, + note: Optional[pulumi.Input[str]] = None, + priority: Optional[pulumi.Input[str]] = None, + proxy_url: Optional[pulumi.Input[str]] = None, + responders: Optional[pulumi.Input[Sequence[pulumi.Input[pulumi.InputType['OpsgenieAlertNotifierResponderArgs']]]]] = None, + send_resolved: Optional[pulumi.Input[bool]] = None, + slug: Optional[pulumi.Input[str]] = None, + source: Optional[pulumi.Input[str]] = None, + tags: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None, + tls_insecure_skip_verify: Optional[pulumi.Input[bool]] = None) -> 'OpsgenieAlertNotifier': + """ + Get an existing OpsgenieAlertNotifier 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. + """ + opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id)) + + __props__ = _OpsgenieAlertNotifierState.__new__(_OpsgenieAlertNotifierState) + + __props__.__dict__["api_key"] = api_key + __props__.__dict__["api_url"] = api_url + __props__.__dict__["basic_auth_password"] = basic_auth_password + __props__.__dict__["basic_auth_username"] = basic_auth_username + __props__.__dict__["bearer_token"] = bearer_token + __props__.__dict__["description"] = description + __props__.__dict__["details"] = details + __props__.__dict__["message"] = message + __props__.__dict__["name"] = name + __props__.__dict__["note"] = note + __props__.__dict__["priority"] = priority + __props__.__dict__["proxy_url"] = proxy_url + __props__.__dict__["responders"] = responders + __props__.__dict__["send_resolved"] = send_resolved + __props__.__dict__["slug"] = slug + __props__.__dict__["source"] = source + __props__.__dict__["tags"] = tags + __props__.__dict__["tls_insecure_skip_verify"] = tls_insecure_skip_verify + return OpsgenieAlertNotifier(resource_name, opts=opts, __props__=__props__) + + @property + @pulumi.getter(name="apiKey") + def api_key(self) -> pulumi.Output[str]: + return pulumi.get(self, "api_key") + + @property + @pulumi.getter(name="apiUrl") + def api_url(self) -> pulumi.Output[Optional[str]]: + return pulumi.get(self, "api_url") + + @property + @pulumi.getter(name="basicAuthPassword") + def basic_auth_password(self) -> pulumi.Output[Optional[str]]: + return pulumi.get(self, "basic_auth_password") + + @property + @pulumi.getter(name="basicAuthUsername") + def basic_auth_username(self) -> pulumi.Output[Optional[str]]: + return pulumi.get(self, "basic_auth_username") + + @property + @pulumi.getter(name="bearerToken") + def bearer_token(self) -> pulumi.Output[Optional[str]]: + return pulumi.get(self, "bearer_token") + + @property + @pulumi.getter + def description(self) -> pulumi.Output[Optional[str]]: + return pulumi.get(self, "description") + + @property + @pulumi.getter + def details(self) -> pulumi.Output[Optional[Mapping[str, str]]]: + return pulumi.get(self, "details") + + @property + @pulumi.getter + def message(self) -> pulumi.Output[Optional[str]]: + return pulumi.get(self, "message") + + @property + @pulumi.getter + def name(self) -> pulumi.Output[str]: + return pulumi.get(self, "name") + + @property + @pulumi.getter + def note(self) -> pulumi.Output[Optional[str]]: + return pulumi.get(self, "note") + + @property + @pulumi.getter + def priority(self) -> pulumi.Output[Optional[str]]: + return pulumi.get(self, "priority") + + @property + @pulumi.getter(name="proxyUrl") + def proxy_url(self) -> pulumi.Output[Optional[str]]: + return pulumi.get(self, "proxy_url") + + @property + @pulumi.getter + def responders(self) -> pulumi.Output[Optional[Sequence['outputs.OpsgenieAlertNotifierResponder']]]: + return pulumi.get(self, "responders") + + @property + @pulumi.getter(name="sendResolved") + def send_resolved(self) -> pulumi.Output[Optional[bool]]: + return pulumi.get(self, "send_resolved") + + @property + @pulumi.getter + def slug(self) -> pulumi.Output[str]: + return pulumi.get(self, "slug") + + @property + @pulumi.getter + def source(self) -> pulumi.Output[Optional[str]]: + return pulumi.get(self, "source") + + @property + @pulumi.getter + def tags(self) -> pulumi.Output[Optional[Sequence[str]]]: + return pulumi.get(self, "tags") + + @property + @pulumi.getter(name="tlsInsecureSkipVerify") + def tls_insecure_skip_verify(self) -> pulumi.Output[Optional[bool]]: + return pulumi.get(self, "tls_insecure_skip_verify") + diff --git a/sdk/python/chronosphereio_chronosphere/outputs.py b/sdk/python/chronosphereio_chronosphere/outputs.py new file mode 100644 index 00000000..4afb022b --- /dev/null +++ b/sdk/python/chronosphereio_chronosphere/outputs.py @@ -0,0 +1,3010 @@ +# coding=utf-8 +# *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import copy +import warnings +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +from . import _utilities +from . import outputs + +__all__ = [ + 'DerivedLabelMetricLabel', + 'DerivedLabelMetricLabelConstructedLabel', + 'DerivedLabelMetricLabelConstructedLabelValueDefinition', + 'DerivedLabelMetricLabelConstructedLabelValueDefinitionFilter', + 'DerivedLabelMetricLabelMappingLabel', + 'DerivedLabelMetricLabelMappingLabelNameMapping', + 'DerivedLabelMetricLabelMappingLabelNameMappingFilter', + 'DerivedLabelMetricLabelMappingLabelNameMappingValueMapping', + 'DerivedLabelMetricLabelMappingLabelValueMapping', + 'DerivedMetricQuery', + 'DerivedMetricQueryQuery', + 'DerivedMetricQueryQueryVariable', + 'DerivedMetricQuerySelector', + 'DropRuleValueBasedDrop', + 'GcpMetricsIntegrationMetricGroup', + 'GcpMetricsIntegrationServiceAccount', + 'MappingRuleStoragePolicy', + 'MonitorQuery', + 'MonitorSchedule', + 'MonitorScheduleRange', + 'MonitorSeriesConditions', + 'MonitorSeriesConditionsCondition', + 'MonitorSeriesConditionsOverride', + 'MonitorSeriesConditionsOverrideCondition', + 'MonitorSeriesConditionsOverrideLabelMatcher', + 'MonitorSignalGrouping', + 'NotificationPolicyDataSourceOverrideResult', + 'NotificationPolicyDataSourceOverrideAlertLabelMatcherResult', + 'NotificationPolicyDataSourceOverrideRouteResult', + 'NotificationPolicyDataSourceRouteResult', + 'NotificationPolicyDataSourceRuleResult', + 'NotificationPolicyOverride', + 'NotificationPolicyOverrideAlertLabelMatcher', + 'NotificationPolicyOverrideRoute', + 'NotificationPolicyRoute', + 'NotificationPolicyRule', + 'OpsgenieAlertNotifierResponder', + 'PagerdutyAlertNotifierImage', + 'PagerdutyAlertNotifierLink', + 'ResourcePoolsConfigDefaultPool', + 'ResourcePoolsConfigDefaultPoolAllocation', + 'ResourcePoolsConfigDefaultPoolPriorities', + 'ResourcePoolsConfigPool', + 'ResourcePoolsConfigPoolAllocation', + 'ResourcePoolsConfigPoolPriorities', + 'RollupRuleStoragePolicies', + 'ServiceAccountRestriction', + 'SlackAlertNotifierAction', + 'SlackAlertNotifierField', + 'TraceJaegerRemoteSamplingStrategyAppliedStrategy', + 'TraceJaegerRemoteSamplingStrategyAppliedStrategyPerOperationStrategies', + 'TraceJaegerRemoteSamplingStrategyAppliedStrategyPerOperationStrategiesPerOperationStrategy', + 'TraceJaegerRemoteSamplingStrategyAppliedStrategyPerOperationStrategiesPerOperationStrategyProbabilisticStrategy', + 'TraceJaegerRemoteSamplingStrategyAppliedStrategyProbabilisticStrategy', + 'TraceJaegerRemoteSamplingStrategyAppliedStrategyRateLimitingStrategy', + 'TraceMetricsRuleGroupBy', + 'TraceMetricsRuleGroupByKey', + 'TraceMetricsRuleTraceFilter', + 'TraceMetricsRuleTraceFilterSpan', + 'TraceMetricsRuleTraceFilterSpanDuration', + 'TraceMetricsRuleTraceFilterSpanError', + 'TraceMetricsRuleTraceFilterSpanOperation', + 'TraceMetricsRuleTraceFilterSpanParentOperation', + 'TraceMetricsRuleTraceFilterSpanParentService', + 'TraceMetricsRuleTraceFilterSpanService', + 'TraceMetricsRuleTraceFilterSpanSpanCount', + 'TraceMetricsRuleTraceFilterSpanTag', + 'TraceMetricsRuleTraceFilterSpanTagNumericValue', + 'TraceMetricsRuleTraceFilterSpanTagValue', + 'TraceMetricsRuleTraceFilterTrace', + 'TraceMetricsRuleTraceFilterTraceDuration', + 'TraceMetricsRuleTraceFilterTraceError', + 'TraceTailSamplingRulesDefaultSampleRate', + 'TraceTailSamplingRulesRule', + 'TraceTailSamplingRulesRuleFilter', + 'TraceTailSamplingRulesRuleFilterSpan', + 'TraceTailSamplingRulesRuleFilterSpanDuration', + 'TraceTailSamplingRulesRuleFilterSpanError', + 'TraceTailSamplingRulesRuleFilterSpanOperation', + 'TraceTailSamplingRulesRuleFilterSpanParentOperation', + 'TraceTailSamplingRulesRuleFilterSpanParentService', + 'TraceTailSamplingRulesRuleFilterSpanService', + 'TraceTailSamplingRulesRuleFilterSpanSpanCount', + 'TraceTailSamplingRulesRuleFilterSpanTag', + 'TraceTailSamplingRulesRuleFilterSpanTagNumericValue', + 'TraceTailSamplingRulesRuleFilterSpanTagValue', + 'TraceTailSamplingRulesRuleFilterTrace', + 'TraceTailSamplingRulesRuleFilterTraceDuration', + 'TraceTailSamplingRulesRuleFilterTraceError', +] + +@pulumi.output_type +class DerivedLabelMetricLabel(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "constructedLabel": + suggest = "constructed_label" + elif key == "mappingLabel": + suggest = "mapping_label" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in DerivedLabelMetricLabel. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + DerivedLabelMetricLabel.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + DerivedLabelMetricLabel.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + constructed_label: Optional['outputs.DerivedLabelMetricLabelConstructedLabel'] = None, + mapping_label: Optional['outputs.DerivedLabelMetricLabelMappingLabel'] = None): + if constructed_label is not None: + pulumi.set(__self__, "constructed_label", constructed_label) + if mapping_label is not None: + pulumi.set(__self__, "mapping_label", mapping_label) + + @property + @pulumi.getter(name="constructedLabel") + def constructed_label(self) -> Optional['outputs.DerivedLabelMetricLabelConstructedLabel']: + return pulumi.get(self, "constructed_label") + + @property + @pulumi.getter(name="mappingLabel") + def mapping_label(self) -> Optional['outputs.DerivedLabelMetricLabelMappingLabel']: + return pulumi.get(self, "mapping_label") + + +@pulumi.output_type +class DerivedLabelMetricLabelConstructedLabel(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "valueDefinitions": + suggest = "value_definitions" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in DerivedLabelMetricLabelConstructedLabel. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + DerivedLabelMetricLabelConstructedLabel.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + DerivedLabelMetricLabelConstructedLabel.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + value_definitions: Sequence['outputs.DerivedLabelMetricLabelConstructedLabelValueDefinition']): + pulumi.set(__self__, "value_definitions", value_definitions) + + @property + @pulumi.getter(name="valueDefinitions") + def value_definitions(self) -> Sequence['outputs.DerivedLabelMetricLabelConstructedLabelValueDefinition']: + return pulumi.get(self, "value_definitions") + + +@pulumi.output_type +class DerivedLabelMetricLabelConstructedLabelValueDefinition(dict): + def __init__(__self__, *, + filters: Sequence['outputs.DerivedLabelMetricLabelConstructedLabelValueDefinitionFilter'], + value: str): + pulumi.set(__self__, "filters", filters) + pulumi.set(__self__, "value", value) + + @property + @pulumi.getter + def filters(self) -> Sequence['outputs.DerivedLabelMetricLabelConstructedLabelValueDefinitionFilter']: + return pulumi.get(self, "filters") + + @property + @pulumi.getter + def value(self) -> str: + return pulumi.get(self, "value") + + +@pulumi.output_type +class DerivedLabelMetricLabelConstructedLabelValueDefinitionFilter(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "valueGlob": + suggest = "value_glob" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in DerivedLabelMetricLabelConstructedLabelValueDefinitionFilter. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + DerivedLabelMetricLabelConstructedLabelValueDefinitionFilter.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + DerivedLabelMetricLabelConstructedLabelValueDefinitionFilter.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + name: str, + value_glob: str): + pulumi.set(__self__, "name", name) + pulumi.set(__self__, "value_glob", value_glob) + + @property + @pulumi.getter + def name(self) -> str: + return pulumi.get(self, "name") + + @property + @pulumi.getter(name="valueGlob") + def value_glob(self) -> str: + return pulumi.get(self, "value_glob") + + +@pulumi.output_type +class DerivedLabelMetricLabelMappingLabel(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "nameMappings": + suggest = "name_mappings" + elif key == "valueMappings": + suggest = "value_mappings" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in DerivedLabelMetricLabelMappingLabel. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + DerivedLabelMetricLabelMappingLabel.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + DerivedLabelMetricLabelMappingLabel.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + name_mappings: Optional[Sequence['outputs.DerivedLabelMetricLabelMappingLabelNameMapping']] = None, + value_mappings: Optional[Sequence['outputs.DerivedLabelMetricLabelMappingLabelValueMapping']] = None): + if name_mappings is not None: + pulumi.set(__self__, "name_mappings", name_mappings) + if value_mappings is not None: + pulumi.set(__self__, "value_mappings", value_mappings) + + @property + @pulumi.getter(name="nameMappings") + def name_mappings(self) -> Optional[Sequence['outputs.DerivedLabelMetricLabelMappingLabelNameMapping']]: + return pulumi.get(self, "name_mappings") + + @property + @pulumi.getter(name="valueMappings") + def value_mappings(self) -> Optional[Sequence['outputs.DerivedLabelMetricLabelMappingLabelValueMapping']]: + return pulumi.get(self, "value_mappings") + + +@pulumi.output_type +class DerivedLabelMetricLabelMappingLabelNameMapping(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "sourceLabel": + suggest = "source_label" + elif key == "valueMappings": + suggest = "value_mappings" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in DerivedLabelMetricLabelMappingLabelNameMapping. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + DerivedLabelMetricLabelMappingLabelNameMapping.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + DerivedLabelMetricLabelMappingLabelNameMapping.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + filters: Sequence['outputs.DerivedLabelMetricLabelMappingLabelNameMappingFilter'], + source_label: str, + value_mappings: Optional[Sequence['outputs.DerivedLabelMetricLabelMappingLabelNameMappingValueMapping']] = None): + pulumi.set(__self__, "filters", filters) + pulumi.set(__self__, "source_label", source_label) + if value_mappings is not None: + pulumi.set(__self__, "value_mappings", value_mappings) + + @property + @pulumi.getter + def filters(self) -> Sequence['outputs.DerivedLabelMetricLabelMappingLabelNameMappingFilter']: + return pulumi.get(self, "filters") + + @property + @pulumi.getter(name="sourceLabel") + def source_label(self) -> str: + return pulumi.get(self, "source_label") + + @property + @pulumi.getter(name="valueMappings") + def value_mappings(self) -> Optional[Sequence['outputs.DerivedLabelMetricLabelMappingLabelNameMappingValueMapping']]: + return pulumi.get(self, "value_mappings") + + +@pulumi.output_type +class DerivedLabelMetricLabelMappingLabelNameMappingFilter(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "valueGlob": + suggest = "value_glob" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in DerivedLabelMetricLabelMappingLabelNameMappingFilter. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + DerivedLabelMetricLabelMappingLabelNameMappingFilter.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + DerivedLabelMetricLabelMappingLabelNameMappingFilter.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + name: str, + value_glob: str): + pulumi.set(__self__, "name", name) + pulumi.set(__self__, "value_glob", value_glob) + + @property + @pulumi.getter + def name(self) -> str: + return pulumi.get(self, "name") + + @property + @pulumi.getter(name="valueGlob") + def value_glob(self) -> str: + return pulumi.get(self, "value_glob") + + +@pulumi.output_type +class DerivedLabelMetricLabelMappingLabelNameMappingValueMapping(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "sourceValueGlobs": + suggest = "source_value_globs" + elif key == "targetValue": + suggest = "target_value" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in DerivedLabelMetricLabelMappingLabelNameMappingValueMapping. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + DerivedLabelMetricLabelMappingLabelNameMappingValueMapping.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + DerivedLabelMetricLabelMappingLabelNameMappingValueMapping.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + source_value_globs: Sequence[str], + target_value: str): + pulumi.set(__self__, "source_value_globs", source_value_globs) + pulumi.set(__self__, "target_value", target_value) + + @property + @pulumi.getter(name="sourceValueGlobs") + def source_value_globs(self) -> Sequence[str]: + return pulumi.get(self, "source_value_globs") + + @property + @pulumi.getter(name="targetValue") + def target_value(self) -> str: + return pulumi.get(self, "target_value") + + +@pulumi.output_type +class DerivedLabelMetricLabelMappingLabelValueMapping(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "sourceValueGlobs": + suggest = "source_value_globs" + elif key == "targetValue": + suggest = "target_value" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in DerivedLabelMetricLabelMappingLabelValueMapping. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + DerivedLabelMetricLabelMappingLabelValueMapping.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + DerivedLabelMetricLabelMappingLabelValueMapping.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + source_value_globs: Sequence[str], + target_value: str): + pulumi.set(__self__, "source_value_globs", source_value_globs) + pulumi.set(__self__, "target_value", target_value) + + @property + @pulumi.getter(name="sourceValueGlobs") + def source_value_globs(self) -> Sequence[str]: + return pulumi.get(self, "source_value_globs") + + @property + @pulumi.getter(name="targetValue") + def target_value(self) -> str: + return pulumi.get(self, "target_value") + + +@pulumi.output_type +class DerivedMetricQuery(dict): + def __init__(__self__, *, + query: 'outputs.DerivedMetricQueryQuery', + selector: Optional['outputs.DerivedMetricQuerySelector'] = None): + pulumi.set(__self__, "query", query) + if selector is not None: + pulumi.set(__self__, "selector", selector) + + @property + @pulumi.getter + def query(self) -> 'outputs.DerivedMetricQueryQuery': + return pulumi.get(self, "query") + + @property + @pulumi.getter + def selector(self) -> Optional['outputs.DerivedMetricQuerySelector']: + return pulumi.get(self, "selector") + + +@pulumi.output_type +class DerivedMetricQueryQuery(dict): + def __init__(__self__, *, + expr: str, + variables: Optional[Sequence['outputs.DerivedMetricQueryQueryVariable']] = None): + pulumi.set(__self__, "expr", expr) + if variables is not None: + pulumi.set(__self__, "variables", variables) + + @property + @pulumi.getter + def expr(self) -> str: + return pulumi.get(self, "expr") + + @property + @pulumi.getter + def variables(self) -> Optional[Sequence['outputs.DerivedMetricQueryQueryVariable']]: + return pulumi.get(self, "variables") + + +@pulumi.output_type +class DerivedMetricQueryQueryVariable(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "defaultSelector": + suggest = "default_selector" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in DerivedMetricQueryQueryVariable. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + DerivedMetricQueryQueryVariable.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + DerivedMetricQueryQueryVariable.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + default_selector: str, + name: str): + pulumi.set(__self__, "default_selector", default_selector) + pulumi.set(__self__, "name", name) + + @property + @pulumi.getter(name="defaultSelector") + def default_selector(self) -> str: + return pulumi.get(self, "default_selector") + + @property + @pulumi.getter + def name(self) -> str: + return pulumi.get(self, "name") + + +@pulumi.output_type +class DerivedMetricQuerySelector(dict): + def __init__(__self__, *, + labels: Optional[Mapping[str, str]] = None): + if labels is not None: + pulumi.set(__self__, "labels", labels) + + @property + @pulumi.getter + def labels(self) -> Optional[Mapping[str, str]]: + return pulumi.get(self, "labels") + + +@pulumi.output_type +class DropRuleValueBasedDrop(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "targetDropValue": + suggest = "target_drop_value" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in DropRuleValueBasedDrop. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + DropRuleValueBasedDrop.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + DropRuleValueBasedDrop.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + target_drop_value: float): + pulumi.set(__self__, "target_drop_value", target_drop_value) + + @property + @pulumi.getter(name="targetDropValue") + def target_drop_value(self) -> float: + return pulumi.get(self, "target_drop_value") + + +@pulumi.output_type +class GcpMetricsIntegrationMetricGroup(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "projectId": + suggest = "project_id" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in GcpMetricsIntegrationMetricGroup. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + GcpMetricsIntegrationMetricGroup.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + GcpMetricsIntegrationMetricGroup.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + project_id: str, + prefixes: Optional[Sequence[str]] = None): + pulumi.set(__self__, "project_id", project_id) + if prefixes is not None: + pulumi.set(__self__, "prefixes", prefixes) + + @property + @pulumi.getter(name="projectId") + def project_id(self) -> str: + return pulumi.get(self, "project_id") + + @property + @pulumi.getter + def prefixes(self) -> Optional[Sequence[str]]: + return pulumi.get(self, "prefixes") + + +@pulumi.output_type +class GcpMetricsIntegrationServiceAccount(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "clientEmail": + suggest = "client_email" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in GcpMetricsIntegrationServiceAccount. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + GcpMetricsIntegrationServiceAccount.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + GcpMetricsIntegrationServiceAccount.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + client_email: str): + pulumi.set(__self__, "client_email", client_email) + + @property + @pulumi.getter(name="clientEmail") + def client_email(self) -> str: + return pulumi.get(self, "client_email") + + +@pulumi.output_type +class MappingRuleStoragePolicy(dict): + def __init__(__self__, *, + resolution: str, + retention: str): + pulumi.set(__self__, "resolution", resolution) + pulumi.set(__self__, "retention", retention) + + @property + @pulumi.getter + def resolution(self) -> str: + return pulumi.get(self, "resolution") + + @property + @pulumi.getter + def retention(self) -> str: + return pulumi.get(self, "retention") + + +@pulumi.output_type +class MonitorQuery(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "graphiteExpr": + suggest = "graphite_expr" + elif key == "prometheusExpr": + suggest = "prometheus_expr" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in MonitorQuery. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + MonitorQuery.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + MonitorQuery.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + graphite_expr: Optional[str] = None, + prometheus_expr: Optional[str] = None): + if graphite_expr is not None: + pulumi.set(__self__, "graphite_expr", graphite_expr) + if prometheus_expr is not None: + pulumi.set(__self__, "prometheus_expr", prometheus_expr) + + @property + @pulumi.getter(name="graphiteExpr") + def graphite_expr(self) -> Optional[str]: + return pulumi.get(self, "graphite_expr") + + @property + @pulumi.getter(name="prometheusExpr") + def prometheus_expr(self) -> Optional[str]: + return pulumi.get(self, "prometheus_expr") + + +@pulumi.output_type +class MonitorSchedule(dict): + def __init__(__self__, *, + timezone: str, + ranges: Optional[Sequence['outputs.MonitorScheduleRange']] = None): + pulumi.set(__self__, "timezone", timezone) + if ranges is not None: + pulumi.set(__self__, "ranges", ranges) + + @property + @pulumi.getter + def timezone(self) -> str: + return pulumi.get(self, "timezone") + + @property + @pulumi.getter + def ranges(self) -> Optional[Sequence['outputs.MonitorScheduleRange']]: + return pulumi.get(self, "ranges") + + +@pulumi.output_type +class MonitorScheduleRange(dict): + def __init__(__self__, *, + day: str, + end: str, + start: str): + pulumi.set(__self__, "day", day) + pulumi.set(__self__, "end", end) + pulumi.set(__self__, "start", start) + + @property + @pulumi.getter + def day(self) -> str: + return pulumi.get(self, "day") + + @property + @pulumi.getter + def end(self) -> str: + return pulumi.get(self, "end") + + @property + @pulumi.getter + def start(self) -> str: + return pulumi.get(self, "start") + + +@pulumi.output_type +class MonitorSeriesConditions(dict): + def __init__(__self__, *, + conditions: Sequence['outputs.MonitorSeriesConditionsCondition'], + overrides: Optional[Sequence['outputs.MonitorSeriesConditionsOverride']] = None): + pulumi.set(__self__, "conditions", conditions) + if overrides is not None: + pulumi.set(__self__, "overrides", overrides) + + @property + @pulumi.getter + def conditions(self) -> Sequence['outputs.MonitorSeriesConditionsCondition']: + return pulumi.get(self, "conditions") + + @property + @pulumi.getter + def overrides(self) -> Optional[Sequence['outputs.MonitorSeriesConditionsOverride']]: + return pulumi.get(self, "overrides") + + +@pulumi.output_type +class MonitorSeriesConditionsCondition(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "resolveSustain": + suggest = "resolve_sustain" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in MonitorSeriesConditionsCondition. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + MonitorSeriesConditionsCondition.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + MonitorSeriesConditionsCondition.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + op: str, + severity: str, + resolve_sustain: Optional[str] = None, + sustain: Optional[str] = None, + value: Optional[float] = None): + pulumi.set(__self__, "op", op) + pulumi.set(__self__, "severity", severity) + if resolve_sustain is not None: + pulumi.set(__self__, "resolve_sustain", resolve_sustain) + if sustain is not None: + pulumi.set(__self__, "sustain", sustain) + if value is not None: + pulumi.set(__self__, "value", value) + + @property + @pulumi.getter + def op(self) -> str: + return pulumi.get(self, "op") + + @property + @pulumi.getter + def severity(self) -> str: + return pulumi.get(self, "severity") + + @property + @pulumi.getter(name="resolveSustain") + def resolve_sustain(self) -> Optional[str]: + return pulumi.get(self, "resolve_sustain") + + @property + @pulumi.getter + def sustain(self) -> Optional[str]: + return pulumi.get(self, "sustain") + + @property + @pulumi.getter + def value(self) -> Optional[float]: + return pulumi.get(self, "value") + + +@pulumi.output_type +class MonitorSeriesConditionsOverride(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "labelMatchers": + suggest = "label_matchers" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in MonitorSeriesConditionsOverride. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + MonitorSeriesConditionsOverride.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + MonitorSeriesConditionsOverride.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + conditions: Sequence['outputs.MonitorSeriesConditionsOverrideCondition'], + label_matchers: Sequence['outputs.MonitorSeriesConditionsOverrideLabelMatcher']): + pulumi.set(__self__, "conditions", conditions) + pulumi.set(__self__, "label_matchers", label_matchers) + + @property + @pulumi.getter + def conditions(self) -> Sequence['outputs.MonitorSeriesConditionsOverrideCondition']: + return pulumi.get(self, "conditions") + + @property + @pulumi.getter(name="labelMatchers") + def label_matchers(self) -> Sequence['outputs.MonitorSeriesConditionsOverrideLabelMatcher']: + return pulumi.get(self, "label_matchers") + + +@pulumi.output_type +class MonitorSeriesConditionsOverrideCondition(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "resolveSustain": + suggest = "resolve_sustain" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in MonitorSeriesConditionsOverrideCondition. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + MonitorSeriesConditionsOverrideCondition.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + MonitorSeriesConditionsOverrideCondition.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + op: str, + severity: str, + resolve_sustain: Optional[str] = None, + sustain: Optional[str] = None, + value: Optional[float] = None): + pulumi.set(__self__, "op", op) + pulumi.set(__self__, "severity", severity) + if resolve_sustain is not None: + pulumi.set(__self__, "resolve_sustain", resolve_sustain) + if sustain is not None: + pulumi.set(__self__, "sustain", sustain) + if value is not None: + pulumi.set(__self__, "value", value) + + @property + @pulumi.getter + def op(self) -> str: + return pulumi.get(self, "op") + + @property + @pulumi.getter + def severity(self) -> str: + return pulumi.get(self, "severity") + + @property + @pulumi.getter(name="resolveSustain") + def resolve_sustain(self) -> Optional[str]: + return pulumi.get(self, "resolve_sustain") + + @property + @pulumi.getter + def sustain(self) -> Optional[str]: + return pulumi.get(self, "sustain") + + @property + @pulumi.getter + def value(self) -> Optional[float]: + return pulumi.get(self, "value") + + +@pulumi.output_type +class MonitorSeriesConditionsOverrideLabelMatcher(dict): + def __init__(__self__, *, + name: str, + type: str, + value: str): + pulumi.set(__self__, "name", name) + pulumi.set(__self__, "type", type) + pulumi.set(__self__, "value", value) + + @property + @pulumi.getter + def name(self) -> str: + return pulumi.get(self, "name") + + @property + @pulumi.getter + def type(self) -> str: + return pulumi.get(self, "type") + + @property + @pulumi.getter + def value(self) -> str: + return pulumi.get(self, "value") + + +@pulumi.output_type +class MonitorSignalGrouping(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "labelNames": + suggest = "label_names" + elif key == "signalPerSeries": + suggest = "signal_per_series" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in MonitorSignalGrouping. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + MonitorSignalGrouping.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + MonitorSignalGrouping.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + label_names: Optional[Sequence[str]] = None, + signal_per_series: Optional[bool] = None): + if label_names is not None: + pulumi.set(__self__, "label_names", label_names) + if signal_per_series is not None: + pulumi.set(__self__, "signal_per_series", signal_per_series) + + @property + @pulumi.getter(name="labelNames") + def label_names(self) -> Optional[Sequence[str]]: + return pulumi.get(self, "label_names") + + @property + @pulumi.getter(name="signalPerSeries") + def signal_per_series(self) -> Optional[bool]: + return pulumi.get(self, "signal_per_series") + + +@pulumi.output_type +class NotificationPolicyDataSourceOverrideResult(dict): + def __init__(__self__, *, + alert_label_matchers: Sequence['outputs.NotificationPolicyDataSourceOverrideAlertLabelMatcherResult'], + routes: Optional[Sequence['outputs.NotificationPolicyDataSourceOverrideRouteResult']] = None): + pulumi.set(__self__, "alert_label_matchers", alert_label_matchers) + if routes is not None: + pulumi.set(__self__, "routes", routes) + + @property + @pulumi.getter(name="alertLabelMatchers") + def alert_label_matchers(self) -> Sequence['outputs.NotificationPolicyDataSourceOverrideAlertLabelMatcherResult']: + return pulumi.get(self, "alert_label_matchers") + + @property + @pulumi.getter + def routes(self) -> Optional[Sequence['outputs.NotificationPolicyDataSourceOverrideRouteResult']]: + return pulumi.get(self, "routes") + + +@pulumi.output_type +class NotificationPolicyDataSourceOverrideAlertLabelMatcherResult(dict): + def __init__(__self__, *, + name: str, + type: str, + value: str): + pulumi.set(__self__, "name", name) + pulumi.set(__self__, "type", type) + pulumi.set(__self__, "value", value) + + @property + @pulumi.getter + def name(self) -> str: + return pulumi.get(self, "name") + + @property + @pulumi.getter + def type(self) -> str: + return pulumi.get(self, "type") + + @property + @pulumi.getter + def value(self) -> str: + return pulumi.get(self, "value") + + +@pulumi.output_type +class NotificationPolicyDataSourceOverrideRouteResult(dict): + def __init__(__self__, *, + severity: str, + notifiers: Optional[Sequence[str]] = None, + repeat_interval: Optional[str] = None): + pulumi.set(__self__, "severity", severity) + if notifiers is not None: + pulumi.set(__self__, "notifiers", notifiers) + if repeat_interval is not None: + pulumi.set(__self__, "repeat_interval", repeat_interval) + + @property + @pulumi.getter + def severity(self) -> str: + return pulumi.get(self, "severity") + + @property + @pulumi.getter + def notifiers(self) -> Optional[Sequence[str]]: + return pulumi.get(self, "notifiers") + + @property + @pulumi.getter(name="repeatInterval") + def repeat_interval(self) -> Optional[str]: + return pulumi.get(self, "repeat_interval") + + +@pulumi.output_type +class NotificationPolicyDataSourceRouteResult(dict): + def __init__(__self__, *, + severity: str, + notifiers: Optional[Sequence[str]] = None, + repeat_interval: Optional[str] = None): + pulumi.set(__self__, "severity", severity) + if notifiers is not None: + pulumi.set(__self__, "notifiers", notifiers) + if repeat_interval is not None: + pulumi.set(__self__, "repeat_interval", repeat_interval) + + @property + @pulumi.getter + def severity(self) -> str: + return pulumi.get(self, "severity") + + @property + @pulumi.getter + def notifiers(self) -> Optional[Sequence[str]]: + return pulumi.get(self, "notifiers") + + @property + @pulumi.getter(name="repeatInterval") + def repeat_interval(self) -> Optional[str]: + return pulumi.get(self, "repeat_interval") + + +@pulumi.output_type +class NotificationPolicyDataSourceRuleResult(dict): + def __init__(__self__, *, + severity: str, + notifiers: Optional[Sequence[str]] = None, + repeat_interval: Optional[str] = None): + pulumi.set(__self__, "severity", severity) + if notifiers is not None: + pulumi.set(__self__, "notifiers", notifiers) + if repeat_interval is not None: + pulumi.set(__self__, "repeat_interval", repeat_interval) + + @property + @pulumi.getter + def severity(self) -> str: + return pulumi.get(self, "severity") + + @property + @pulumi.getter + def notifiers(self) -> Optional[Sequence[str]]: + return pulumi.get(self, "notifiers") + + @property + @pulumi.getter(name="repeatInterval") + def repeat_interval(self) -> Optional[str]: + return pulumi.get(self, "repeat_interval") + + +@pulumi.output_type +class NotificationPolicyOverride(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "alertLabelMatchers": + suggest = "alert_label_matchers" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in NotificationPolicyOverride. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + NotificationPolicyOverride.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + NotificationPolicyOverride.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + alert_label_matchers: Sequence['outputs.NotificationPolicyOverrideAlertLabelMatcher'], + routes: Optional[Sequence['outputs.NotificationPolicyOverrideRoute']] = None): + pulumi.set(__self__, "alert_label_matchers", alert_label_matchers) + if routes is not None: + pulumi.set(__self__, "routes", routes) + + @property + @pulumi.getter(name="alertLabelMatchers") + def alert_label_matchers(self) -> Sequence['outputs.NotificationPolicyOverrideAlertLabelMatcher']: + return pulumi.get(self, "alert_label_matchers") + + @property + @pulumi.getter + def routes(self) -> Optional[Sequence['outputs.NotificationPolicyOverrideRoute']]: + return pulumi.get(self, "routes") + + +@pulumi.output_type +class NotificationPolicyOverrideAlertLabelMatcher(dict): + def __init__(__self__, *, + name: str, + type: str, + value: str): + pulumi.set(__self__, "name", name) + pulumi.set(__self__, "type", type) + pulumi.set(__self__, "value", value) + + @property + @pulumi.getter + def name(self) -> str: + return pulumi.get(self, "name") + + @property + @pulumi.getter + def type(self) -> str: + return pulumi.get(self, "type") + + @property + @pulumi.getter + def value(self) -> str: + return pulumi.get(self, "value") + + +@pulumi.output_type +class NotificationPolicyOverrideRoute(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "repeatInterval": + suggest = "repeat_interval" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in NotificationPolicyOverrideRoute. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + NotificationPolicyOverrideRoute.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + NotificationPolicyOverrideRoute.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + severity: str, + notifiers: Optional[Sequence[str]] = None, + repeat_interval: Optional[str] = None): + pulumi.set(__self__, "severity", severity) + if notifiers is not None: + pulumi.set(__self__, "notifiers", notifiers) + if repeat_interval is not None: + pulumi.set(__self__, "repeat_interval", repeat_interval) + + @property + @pulumi.getter + def severity(self) -> str: + return pulumi.get(self, "severity") + + @property + @pulumi.getter + def notifiers(self) -> Optional[Sequence[str]]: + return pulumi.get(self, "notifiers") + + @property + @pulumi.getter(name="repeatInterval") + def repeat_interval(self) -> Optional[str]: + return pulumi.get(self, "repeat_interval") + + +@pulumi.output_type +class NotificationPolicyRoute(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "repeatInterval": + suggest = "repeat_interval" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in NotificationPolicyRoute. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + NotificationPolicyRoute.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + NotificationPolicyRoute.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + severity: str, + notifiers: Optional[Sequence[str]] = None, + repeat_interval: Optional[str] = None): + pulumi.set(__self__, "severity", severity) + if notifiers is not None: + pulumi.set(__self__, "notifiers", notifiers) + if repeat_interval is not None: + pulumi.set(__self__, "repeat_interval", repeat_interval) + + @property + @pulumi.getter + def severity(self) -> str: + return pulumi.get(self, "severity") + + @property + @pulumi.getter + def notifiers(self) -> Optional[Sequence[str]]: + return pulumi.get(self, "notifiers") + + @property + @pulumi.getter(name="repeatInterval") + def repeat_interval(self) -> Optional[str]: + return pulumi.get(self, "repeat_interval") + + +@pulumi.output_type +class NotificationPolicyRule(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "repeatInterval": + suggest = "repeat_interval" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in NotificationPolicyRule. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + NotificationPolicyRule.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + NotificationPolicyRule.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + severity: str, + notifiers: Optional[Sequence[str]] = None, + repeat_interval: Optional[str] = None): + pulumi.set(__self__, "severity", severity) + if notifiers is not None: + pulumi.set(__self__, "notifiers", notifiers) + if repeat_interval is not None: + pulumi.set(__self__, "repeat_interval", repeat_interval) + + @property + @pulumi.getter + def severity(self) -> str: + return pulumi.get(self, "severity") + + @property + @pulumi.getter + def notifiers(self) -> Optional[Sequence[str]]: + return pulumi.get(self, "notifiers") + + @property + @pulumi.getter(name="repeatInterval") + def repeat_interval(self) -> Optional[str]: + return pulumi.get(self, "repeat_interval") + + +@pulumi.output_type +class OpsgenieAlertNotifierResponder(dict): + def __init__(__self__, *, + type: str, + id: Optional[str] = None, + name: Optional[str] = None, + username: Optional[str] = None): + pulumi.set(__self__, "type", type) + if id is not None: + pulumi.set(__self__, "id", id) + if name is not None: + pulumi.set(__self__, "name", name) + if username is not None: + pulumi.set(__self__, "username", username) + + @property + @pulumi.getter + def type(self) -> str: + return pulumi.get(self, "type") + + @property + @pulumi.getter + def id(self) -> Optional[str]: + return pulumi.get(self, "id") + + @property + @pulumi.getter + def name(self) -> Optional[str]: + return pulumi.get(self, "name") + + @property + @pulumi.getter + def username(self) -> Optional[str]: + return pulumi.get(self, "username") + + +@pulumi.output_type +class PagerdutyAlertNotifierImage(dict): + def __init__(__self__, *, + src: str, + alt: Optional[str] = None, + href: Optional[str] = None): + pulumi.set(__self__, "src", src) + if alt is not None: + pulumi.set(__self__, "alt", alt) + if href is not None: + pulumi.set(__self__, "href", href) + + @property + @pulumi.getter + def src(self) -> str: + return pulumi.get(self, "src") + + @property + @pulumi.getter + def alt(self) -> Optional[str]: + return pulumi.get(self, "alt") + + @property + @pulumi.getter + def href(self) -> Optional[str]: + return pulumi.get(self, "href") + + +@pulumi.output_type +class PagerdutyAlertNotifierLink(dict): + def __init__(__self__, *, + href: str, + text: Optional[str] = None): + pulumi.set(__self__, "href", href) + if text is not None: + pulumi.set(__self__, "text", text) + + @property + @pulumi.getter + def href(self) -> str: + return pulumi.get(self, "href") + + @property + @pulumi.getter + def text(self) -> Optional[str]: + return pulumi.get(self, "text") + + +@pulumi.output_type +class ResourcePoolsConfigDefaultPool(dict): + def __init__(__self__, *, + allocation: 'outputs.ResourcePoolsConfigDefaultPoolAllocation', + priorities: Optional['outputs.ResourcePoolsConfigDefaultPoolPriorities'] = None): + pulumi.set(__self__, "allocation", allocation) + if priorities is not None: + pulumi.set(__self__, "priorities", priorities) + + @property + @pulumi.getter + def allocation(self) -> 'outputs.ResourcePoolsConfigDefaultPoolAllocation': + return pulumi.get(self, "allocation") + + @property + @pulumi.getter + def priorities(self) -> Optional['outputs.ResourcePoolsConfigDefaultPoolPriorities']: + return pulumi.get(self, "priorities") + + +@pulumi.output_type +class ResourcePoolsConfigDefaultPoolAllocation(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "percentOfLicense": + suggest = "percent_of_license" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in ResourcePoolsConfigDefaultPoolAllocation. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + ResourcePoolsConfigDefaultPoolAllocation.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + ResourcePoolsConfigDefaultPoolAllocation.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + percent_of_license: float): + pulumi.set(__self__, "percent_of_license", percent_of_license) + + @property + @pulumi.getter(name="percentOfLicense") + def percent_of_license(self) -> float: + return pulumi.get(self, "percent_of_license") + + +@pulumi.output_type +class ResourcePoolsConfigDefaultPoolPriorities(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "highPriorityMatchRules": + suggest = "high_priority_match_rules" + elif key == "lowPriorityMatchRules": + suggest = "low_priority_match_rules" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in ResourcePoolsConfigDefaultPoolPriorities. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + ResourcePoolsConfigDefaultPoolPriorities.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + ResourcePoolsConfigDefaultPoolPriorities.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + high_priority_match_rules: Optional[Sequence[str]] = None, + low_priority_match_rules: Optional[Sequence[str]] = None): + if high_priority_match_rules is not None: + pulumi.set(__self__, "high_priority_match_rules", high_priority_match_rules) + if low_priority_match_rules is not None: + pulumi.set(__self__, "low_priority_match_rules", low_priority_match_rules) + + @property + @pulumi.getter(name="highPriorityMatchRules") + def high_priority_match_rules(self) -> Optional[Sequence[str]]: + return pulumi.get(self, "high_priority_match_rules") + + @property + @pulumi.getter(name="lowPriorityMatchRules") + def low_priority_match_rules(self) -> Optional[Sequence[str]]: + return pulumi.get(self, "low_priority_match_rules") + + +@pulumi.output_type +class ResourcePoolsConfigPool(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "matchRule": + suggest = "match_rule" + elif key == "matchRules": + suggest = "match_rules" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in ResourcePoolsConfigPool. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + ResourcePoolsConfigPool.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + ResourcePoolsConfigPool.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + allocation: 'outputs.ResourcePoolsConfigPoolAllocation', + name: str, + match_rule: Optional[str] = None, + match_rules: Optional[Sequence[str]] = None, + priorities: Optional['outputs.ResourcePoolsConfigPoolPriorities'] = None): + pulumi.set(__self__, "allocation", allocation) + pulumi.set(__self__, "name", name) + if match_rule is not None: + pulumi.set(__self__, "match_rule", match_rule) + if match_rules is not None: + pulumi.set(__self__, "match_rules", match_rules) + if priorities is not None: + pulumi.set(__self__, "priorities", priorities) + + @property + @pulumi.getter + def allocation(self) -> 'outputs.ResourcePoolsConfigPoolAllocation': + return pulumi.get(self, "allocation") + + @property + @pulumi.getter + def name(self) -> str: + return pulumi.get(self, "name") + + @property + @pulumi.getter(name="matchRule") + def match_rule(self) -> Optional[str]: + warnings.warn("""use match_rules""", DeprecationWarning) + pulumi.log.warn("""match_rule is deprecated: use match_rules""") + + return pulumi.get(self, "match_rule") + + @property + @pulumi.getter(name="matchRules") + def match_rules(self) -> Optional[Sequence[str]]: + return pulumi.get(self, "match_rules") + + @property + @pulumi.getter + def priorities(self) -> Optional['outputs.ResourcePoolsConfigPoolPriorities']: + return pulumi.get(self, "priorities") + + +@pulumi.output_type +class ResourcePoolsConfigPoolAllocation(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "percentOfLicense": + suggest = "percent_of_license" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in ResourcePoolsConfigPoolAllocation. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + ResourcePoolsConfigPoolAllocation.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + ResourcePoolsConfigPoolAllocation.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + percent_of_license: float): + pulumi.set(__self__, "percent_of_license", percent_of_license) + + @property + @pulumi.getter(name="percentOfLicense") + def percent_of_license(self) -> float: + return pulumi.get(self, "percent_of_license") + + +@pulumi.output_type +class ResourcePoolsConfigPoolPriorities(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "highPriorityMatchRules": + suggest = "high_priority_match_rules" + elif key == "lowPriorityMatchRules": + suggest = "low_priority_match_rules" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in ResourcePoolsConfigPoolPriorities. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + ResourcePoolsConfigPoolPriorities.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + ResourcePoolsConfigPoolPriorities.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + high_priority_match_rules: Optional[Sequence[str]] = None, + low_priority_match_rules: Optional[Sequence[str]] = None): + if high_priority_match_rules is not None: + pulumi.set(__self__, "high_priority_match_rules", high_priority_match_rules) + if low_priority_match_rules is not None: + pulumi.set(__self__, "low_priority_match_rules", low_priority_match_rules) + + @property + @pulumi.getter(name="highPriorityMatchRules") + def high_priority_match_rules(self) -> Optional[Sequence[str]]: + return pulumi.get(self, "high_priority_match_rules") + + @property + @pulumi.getter(name="lowPriorityMatchRules") + def low_priority_match_rules(self) -> Optional[Sequence[str]]: + return pulumi.get(self, "low_priority_match_rules") + + +@pulumi.output_type +class RollupRuleStoragePolicies(dict): + def __init__(__self__, *, + resolution: str, + retention: str): + pulumi.set(__self__, "resolution", resolution) + pulumi.set(__self__, "retention", retention) + + @property + @pulumi.getter + def resolution(self) -> str: + return pulumi.get(self, "resolution") + + @property + @pulumi.getter + def retention(self) -> str: + return pulumi.get(self, "retention") + + +@pulumi.output_type +class ServiceAccountRestriction(dict): + def __init__(__self__, *, + permission: str, + labels: Optional[Mapping[str, str]] = None): + pulumi.set(__self__, "permission", permission) + if labels is not None: + pulumi.set(__self__, "labels", labels) + + @property + @pulumi.getter + def permission(self) -> str: + return pulumi.get(self, "permission") + + @property + @pulumi.getter + def labels(self) -> Optional[Mapping[str, str]]: + return pulumi.get(self, "labels") + + +@pulumi.output_type +class SlackAlertNotifierAction(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "actionConfirmDismissText": + suggest = "action_confirm_dismiss_text" + elif key == "actionConfirmOkText": + suggest = "action_confirm_ok_text" + elif key == "actionConfirmText": + suggest = "action_confirm_text" + elif key == "actionConfirmTile": + suggest = "action_confirm_tile" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in SlackAlertNotifierAction. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + SlackAlertNotifierAction.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + SlackAlertNotifierAction.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + action_confirm_dismiss_text: Optional[str] = None, + action_confirm_ok_text: Optional[str] = None, + action_confirm_text: Optional[str] = None, + action_confirm_tile: Optional[str] = None, + name: Optional[str] = None, + style: Optional[str] = None, + text: Optional[str] = None, + type: Optional[str] = None, + url: Optional[str] = None, + value: Optional[str] = None): + if action_confirm_dismiss_text is not None: + pulumi.set(__self__, "action_confirm_dismiss_text", action_confirm_dismiss_text) + if action_confirm_ok_text is not None: + pulumi.set(__self__, "action_confirm_ok_text", action_confirm_ok_text) + if action_confirm_text is not None: + pulumi.set(__self__, "action_confirm_text", action_confirm_text) + if action_confirm_tile is not None: + pulumi.set(__self__, "action_confirm_tile", action_confirm_tile) + if name is not None: + pulumi.set(__self__, "name", name) + if style is not None: + pulumi.set(__self__, "style", style) + if text is not None: + pulumi.set(__self__, "text", text) + if type is not None: + pulumi.set(__self__, "type", type) + if url is not None: + pulumi.set(__self__, "url", url) + if value is not None: + pulumi.set(__self__, "value", value) + + @property + @pulumi.getter(name="actionConfirmDismissText") + def action_confirm_dismiss_text(self) -> Optional[str]: + return pulumi.get(self, "action_confirm_dismiss_text") + + @property + @pulumi.getter(name="actionConfirmOkText") + def action_confirm_ok_text(self) -> Optional[str]: + return pulumi.get(self, "action_confirm_ok_text") + + @property + @pulumi.getter(name="actionConfirmText") + def action_confirm_text(self) -> Optional[str]: + return pulumi.get(self, "action_confirm_text") + + @property + @pulumi.getter(name="actionConfirmTile") + def action_confirm_tile(self) -> Optional[str]: + return pulumi.get(self, "action_confirm_tile") + + @property + @pulumi.getter + def name(self) -> Optional[str]: + return pulumi.get(self, "name") + + @property + @pulumi.getter + def style(self) -> Optional[str]: + return pulumi.get(self, "style") + + @property + @pulumi.getter + def text(self) -> Optional[str]: + return pulumi.get(self, "text") + + @property + @pulumi.getter + def type(self) -> Optional[str]: + return pulumi.get(self, "type") + + @property + @pulumi.getter + def url(self) -> Optional[str]: + return pulumi.get(self, "url") + + @property + @pulumi.getter + def value(self) -> Optional[str]: + return pulumi.get(self, "value") + + +@pulumi.output_type +class SlackAlertNotifierField(dict): + def __init__(__self__, *, + short: Optional[bool] = None, + title: Optional[str] = None, + value: Optional[str] = None): + if short is not None: + pulumi.set(__self__, "short", short) + if title is not None: + pulumi.set(__self__, "title", title) + if value is not None: + pulumi.set(__self__, "value", value) + + @property + @pulumi.getter + def short(self) -> Optional[bool]: + return pulumi.get(self, "short") + + @property + @pulumi.getter + def title(self) -> Optional[str]: + return pulumi.get(self, "title") + + @property + @pulumi.getter + def value(self) -> Optional[str]: + return pulumi.get(self, "value") + + +@pulumi.output_type +class TraceJaegerRemoteSamplingStrategyAppliedStrategy(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "perOperationStrategies": + suggest = "per_operation_strategies" + elif key == "probabilisticStrategy": + suggest = "probabilistic_strategy" + elif key == "rateLimitingStrategy": + suggest = "rate_limiting_strategy" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in TraceJaegerRemoteSamplingStrategyAppliedStrategy. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + TraceJaegerRemoteSamplingStrategyAppliedStrategy.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + TraceJaegerRemoteSamplingStrategyAppliedStrategy.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + per_operation_strategies: Optional['outputs.TraceJaegerRemoteSamplingStrategyAppliedStrategyPerOperationStrategies'] = None, + probabilistic_strategy: Optional['outputs.TraceJaegerRemoteSamplingStrategyAppliedStrategyProbabilisticStrategy'] = None, + rate_limiting_strategy: Optional['outputs.TraceJaegerRemoteSamplingStrategyAppliedStrategyRateLimitingStrategy'] = None): + if per_operation_strategies is not None: + pulumi.set(__self__, "per_operation_strategies", per_operation_strategies) + if probabilistic_strategy is not None: + pulumi.set(__self__, "probabilistic_strategy", probabilistic_strategy) + if rate_limiting_strategy is not None: + pulumi.set(__self__, "rate_limiting_strategy", rate_limiting_strategy) + + @property + @pulumi.getter(name="perOperationStrategies") + def per_operation_strategies(self) -> Optional['outputs.TraceJaegerRemoteSamplingStrategyAppliedStrategyPerOperationStrategies']: + return pulumi.get(self, "per_operation_strategies") + + @property + @pulumi.getter(name="probabilisticStrategy") + def probabilistic_strategy(self) -> Optional['outputs.TraceJaegerRemoteSamplingStrategyAppliedStrategyProbabilisticStrategy']: + return pulumi.get(self, "probabilistic_strategy") + + @property + @pulumi.getter(name="rateLimitingStrategy") + def rate_limiting_strategy(self) -> Optional['outputs.TraceJaegerRemoteSamplingStrategyAppliedStrategyRateLimitingStrategy']: + return pulumi.get(self, "rate_limiting_strategy") + + +@pulumi.output_type +class TraceJaegerRemoteSamplingStrategyAppliedStrategyPerOperationStrategies(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "defaultSamplingRate": + suggest = "default_sampling_rate" + elif key == "defaultLowerBoundTracesPerSecond": + suggest = "default_lower_bound_traces_per_second" + elif key == "defaultUpperBoundTracesPerSecond": + suggest = "default_upper_bound_traces_per_second" + elif key == "perOperationStrategies": + suggest = "per_operation_strategies" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in TraceJaegerRemoteSamplingStrategyAppliedStrategyPerOperationStrategies. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + TraceJaegerRemoteSamplingStrategyAppliedStrategyPerOperationStrategies.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + TraceJaegerRemoteSamplingStrategyAppliedStrategyPerOperationStrategies.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + default_sampling_rate: float, + default_lower_bound_traces_per_second: Optional[float] = None, + default_upper_bound_traces_per_second: Optional[float] = None, + per_operation_strategies: Optional[Sequence['outputs.TraceJaegerRemoteSamplingStrategyAppliedStrategyPerOperationStrategiesPerOperationStrategy']] = None): + pulumi.set(__self__, "default_sampling_rate", default_sampling_rate) + if default_lower_bound_traces_per_second is not None: + pulumi.set(__self__, "default_lower_bound_traces_per_second", default_lower_bound_traces_per_second) + if default_upper_bound_traces_per_second is not None: + pulumi.set(__self__, "default_upper_bound_traces_per_second", default_upper_bound_traces_per_second) + if per_operation_strategies is not None: + pulumi.set(__self__, "per_operation_strategies", per_operation_strategies) + + @property + @pulumi.getter(name="defaultSamplingRate") + def default_sampling_rate(self) -> float: + return pulumi.get(self, "default_sampling_rate") + + @property + @pulumi.getter(name="defaultLowerBoundTracesPerSecond") + def default_lower_bound_traces_per_second(self) -> Optional[float]: + return pulumi.get(self, "default_lower_bound_traces_per_second") + + @property + @pulumi.getter(name="defaultUpperBoundTracesPerSecond") + def default_upper_bound_traces_per_second(self) -> Optional[float]: + return pulumi.get(self, "default_upper_bound_traces_per_second") + + @property + @pulumi.getter(name="perOperationStrategies") + def per_operation_strategies(self) -> Optional[Sequence['outputs.TraceJaegerRemoteSamplingStrategyAppliedStrategyPerOperationStrategiesPerOperationStrategy']]: + return pulumi.get(self, "per_operation_strategies") + + +@pulumi.output_type +class TraceJaegerRemoteSamplingStrategyAppliedStrategyPerOperationStrategiesPerOperationStrategy(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "probabilisticStrategy": + suggest = "probabilistic_strategy" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in TraceJaegerRemoteSamplingStrategyAppliedStrategyPerOperationStrategiesPerOperationStrategy. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + TraceJaegerRemoteSamplingStrategyAppliedStrategyPerOperationStrategiesPerOperationStrategy.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + TraceJaegerRemoteSamplingStrategyAppliedStrategyPerOperationStrategiesPerOperationStrategy.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + operation: str, + probabilistic_strategy: 'outputs.TraceJaegerRemoteSamplingStrategyAppliedStrategyPerOperationStrategiesPerOperationStrategyProbabilisticStrategy'): + pulumi.set(__self__, "operation", operation) + pulumi.set(__self__, "probabilistic_strategy", probabilistic_strategy) + + @property + @pulumi.getter + def operation(self) -> str: + return pulumi.get(self, "operation") + + @property + @pulumi.getter(name="probabilisticStrategy") + def probabilistic_strategy(self) -> 'outputs.TraceJaegerRemoteSamplingStrategyAppliedStrategyPerOperationStrategiesPerOperationStrategyProbabilisticStrategy': + return pulumi.get(self, "probabilistic_strategy") + + +@pulumi.output_type +class TraceJaegerRemoteSamplingStrategyAppliedStrategyPerOperationStrategiesPerOperationStrategyProbabilisticStrategy(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "samplingRate": + suggest = "sampling_rate" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in TraceJaegerRemoteSamplingStrategyAppliedStrategyPerOperationStrategiesPerOperationStrategyProbabilisticStrategy. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + TraceJaegerRemoteSamplingStrategyAppliedStrategyPerOperationStrategiesPerOperationStrategyProbabilisticStrategy.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + TraceJaegerRemoteSamplingStrategyAppliedStrategyPerOperationStrategiesPerOperationStrategyProbabilisticStrategy.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + sampling_rate: float): + pulumi.set(__self__, "sampling_rate", sampling_rate) + + @property + @pulumi.getter(name="samplingRate") + def sampling_rate(self) -> float: + return pulumi.get(self, "sampling_rate") + + +@pulumi.output_type +class TraceJaegerRemoteSamplingStrategyAppliedStrategyProbabilisticStrategy(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "samplingRate": + suggest = "sampling_rate" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in TraceJaegerRemoteSamplingStrategyAppliedStrategyProbabilisticStrategy. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + TraceJaegerRemoteSamplingStrategyAppliedStrategyProbabilisticStrategy.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + TraceJaegerRemoteSamplingStrategyAppliedStrategyProbabilisticStrategy.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + sampling_rate: float): + pulumi.set(__self__, "sampling_rate", sampling_rate) + + @property + @pulumi.getter(name="samplingRate") + def sampling_rate(self) -> float: + return pulumi.get(self, "sampling_rate") + + +@pulumi.output_type +class TraceJaegerRemoteSamplingStrategyAppliedStrategyRateLimitingStrategy(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "maxTracesPerSecond": + suggest = "max_traces_per_second" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in TraceJaegerRemoteSamplingStrategyAppliedStrategyRateLimitingStrategy. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + TraceJaegerRemoteSamplingStrategyAppliedStrategyRateLimitingStrategy.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + TraceJaegerRemoteSamplingStrategyAppliedStrategyRateLimitingStrategy.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + max_traces_per_second: int): + pulumi.set(__self__, "max_traces_per_second", max_traces_per_second) + + @property + @pulumi.getter(name="maxTracesPerSecond") + def max_traces_per_second(self) -> int: + return pulumi.get(self, "max_traces_per_second") + + +@pulumi.output_type +class TraceMetricsRuleGroupBy(dict): + def __init__(__self__, *, + key: 'outputs.TraceMetricsRuleGroupByKey', + label: str): + pulumi.set(__self__, "key", key) + pulumi.set(__self__, "label", label) + + @property + @pulumi.getter + def key(self) -> 'outputs.TraceMetricsRuleGroupByKey': + return pulumi.get(self, "key") + + @property + @pulumi.getter + def label(self) -> str: + return pulumi.get(self, "label") + + +@pulumi.output_type +class TraceMetricsRuleGroupByKey(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "namedKey": + suggest = "named_key" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in TraceMetricsRuleGroupByKey. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + TraceMetricsRuleGroupByKey.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + TraceMetricsRuleGroupByKey.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + type: str, + named_key: Optional[str] = None): + pulumi.set(__self__, "type", type) + if named_key is not None: + pulumi.set(__self__, "named_key", named_key) + + @property + @pulumi.getter + def type(self) -> str: + return pulumi.get(self, "type") + + @property + @pulumi.getter(name="namedKey") + def named_key(self) -> Optional[str]: + return pulumi.get(self, "named_key") + + +@pulumi.output_type +class TraceMetricsRuleTraceFilter(dict): + def __init__(__self__, *, + spans: Optional[Sequence['outputs.TraceMetricsRuleTraceFilterSpan']] = None, + trace: Optional['outputs.TraceMetricsRuleTraceFilterTrace'] = None): + if spans is not None: + pulumi.set(__self__, "spans", spans) + if trace is not None: + pulumi.set(__self__, "trace", trace) + + @property + @pulumi.getter + def spans(self) -> Optional[Sequence['outputs.TraceMetricsRuleTraceFilterSpan']]: + return pulumi.get(self, "spans") + + @property + @pulumi.getter + def trace(self) -> Optional['outputs.TraceMetricsRuleTraceFilterTrace']: + return pulumi.get(self, "trace") + + +@pulumi.output_type +class TraceMetricsRuleTraceFilterSpan(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "matchType": + suggest = "match_type" + elif key == "parentOperation": + suggest = "parent_operation" + elif key == "parentService": + suggest = "parent_service" + elif key == "spanCount": + suggest = "span_count" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in TraceMetricsRuleTraceFilterSpan. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + TraceMetricsRuleTraceFilterSpan.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + TraceMetricsRuleTraceFilterSpan.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + duration: Optional['outputs.TraceMetricsRuleTraceFilterSpanDuration'] = None, + error: Optional['outputs.TraceMetricsRuleTraceFilterSpanError'] = None, + match_type: Optional[str] = None, + operation: Optional['outputs.TraceMetricsRuleTraceFilterSpanOperation'] = None, + parent_operation: Optional['outputs.TraceMetricsRuleTraceFilterSpanParentOperation'] = None, + parent_service: Optional['outputs.TraceMetricsRuleTraceFilterSpanParentService'] = None, + service: Optional['outputs.TraceMetricsRuleTraceFilterSpanService'] = None, + span_count: Optional['outputs.TraceMetricsRuleTraceFilterSpanSpanCount'] = None, + tags: Optional[Sequence['outputs.TraceMetricsRuleTraceFilterSpanTag']] = None): + if duration is not None: + pulumi.set(__self__, "duration", duration) + if error is not None: + pulumi.set(__self__, "error", error) + if match_type is not None: + pulumi.set(__self__, "match_type", match_type) + if operation is not None: + pulumi.set(__self__, "operation", operation) + if parent_operation is not None: + pulumi.set(__self__, "parent_operation", parent_operation) + if parent_service is not None: + pulumi.set(__self__, "parent_service", parent_service) + if service is not None: + pulumi.set(__self__, "service", service) + if span_count is not None: + pulumi.set(__self__, "span_count", span_count) + if tags is not None: + pulumi.set(__self__, "tags", tags) + + @property + @pulumi.getter + def duration(self) -> Optional['outputs.TraceMetricsRuleTraceFilterSpanDuration']: + return pulumi.get(self, "duration") + + @property + @pulumi.getter + def error(self) -> Optional['outputs.TraceMetricsRuleTraceFilterSpanError']: + return pulumi.get(self, "error") + + @property + @pulumi.getter(name="matchType") + def match_type(self) -> Optional[str]: + return pulumi.get(self, "match_type") + + @property + @pulumi.getter + def operation(self) -> Optional['outputs.TraceMetricsRuleTraceFilterSpanOperation']: + return pulumi.get(self, "operation") + + @property + @pulumi.getter(name="parentOperation") + def parent_operation(self) -> Optional['outputs.TraceMetricsRuleTraceFilterSpanParentOperation']: + return pulumi.get(self, "parent_operation") + + @property + @pulumi.getter(name="parentService") + def parent_service(self) -> Optional['outputs.TraceMetricsRuleTraceFilterSpanParentService']: + return pulumi.get(self, "parent_service") + + @property + @pulumi.getter + def service(self) -> Optional['outputs.TraceMetricsRuleTraceFilterSpanService']: + return pulumi.get(self, "service") + + @property + @pulumi.getter(name="spanCount") + def span_count(self) -> Optional['outputs.TraceMetricsRuleTraceFilterSpanSpanCount']: + return pulumi.get(self, "span_count") + + @property + @pulumi.getter + def tags(self) -> Optional[Sequence['outputs.TraceMetricsRuleTraceFilterSpanTag']]: + return pulumi.get(self, "tags") + + +@pulumi.output_type +class TraceMetricsRuleTraceFilterSpanDuration(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "maxSeconds": + suggest = "max_seconds" + elif key == "minSeconds": + suggest = "min_seconds" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in TraceMetricsRuleTraceFilterSpanDuration. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + TraceMetricsRuleTraceFilterSpanDuration.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + TraceMetricsRuleTraceFilterSpanDuration.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + max_seconds: Optional[float] = None, + min_seconds: Optional[float] = None): + if max_seconds is not None: + pulumi.set(__self__, "max_seconds", max_seconds) + if min_seconds is not None: + pulumi.set(__self__, "min_seconds", min_seconds) + + @property + @pulumi.getter(name="maxSeconds") + def max_seconds(self) -> Optional[float]: + return pulumi.get(self, "max_seconds") + + @property + @pulumi.getter(name="minSeconds") + def min_seconds(self) -> Optional[float]: + return pulumi.get(self, "min_seconds") + + +@pulumi.output_type +class TraceMetricsRuleTraceFilterSpanError(dict): + def __init__(__self__, *, + value: bool): + pulumi.set(__self__, "value", value) + + @property + @pulumi.getter + def value(self) -> bool: + return pulumi.get(self, "value") + + +@pulumi.output_type +class TraceMetricsRuleTraceFilterSpanOperation(dict): + def __init__(__self__, *, + value: str, + match: Optional[str] = None): + pulumi.set(__self__, "value", value) + if match is not None: + pulumi.set(__self__, "match", match) + + @property + @pulumi.getter + def value(self) -> str: + return pulumi.get(self, "value") + + @property + @pulumi.getter + def match(self) -> Optional[str]: + return pulumi.get(self, "match") + + +@pulumi.output_type +class TraceMetricsRuleTraceFilterSpanParentOperation(dict): + def __init__(__self__, *, + value: str, + match: Optional[str] = None): + pulumi.set(__self__, "value", value) + if match is not None: + pulumi.set(__self__, "match", match) + + @property + @pulumi.getter + def value(self) -> str: + return pulumi.get(self, "value") + + @property + @pulumi.getter + def match(self) -> Optional[str]: + return pulumi.get(self, "match") + + +@pulumi.output_type +class TraceMetricsRuleTraceFilterSpanParentService(dict): + def __init__(__self__, *, + value: str, + match: Optional[str] = None): + pulumi.set(__self__, "value", value) + if match is not None: + pulumi.set(__self__, "match", match) + + @property + @pulumi.getter + def value(self) -> str: + return pulumi.get(self, "value") + + @property + @pulumi.getter + def match(self) -> Optional[str]: + return pulumi.get(self, "match") + + +@pulumi.output_type +class TraceMetricsRuleTraceFilterSpanService(dict): + def __init__(__self__, *, + value: str, + match: Optional[str] = None): + pulumi.set(__self__, "value", value) + if match is not None: + pulumi.set(__self__, "match", match) + + @property + @pulumi.getter + def value(self) -> str: + return pulumi.get(self, "value") + + @property + @pulumi.getter + def match(self) -> Optional[str]: + return pulumi.get(self, "match") + + +@pulumi.output_type +class TraceMetricsRuleTraceFilterSpanSpanCount(dict): + def __init__(__self__, *, + max: Optional[int] = None, + min: Optional[int] = None): + if max is not None: + pulumi.set(__self__, "max", max) + if min is not None: + pulumi.set(__self__, "min", min) + + @property + @pulumi.getter + def max(self) -> Optional[int]: + return pulumi.get(self, "max") + + @property + @pulumi.getter + def min(self) -> Optional[int]: + return pulumi.get(self, "min") + + +@pulumi.output_type +class TraceMetricsRuleTraceFilterSpanTag(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "numericValue": + suggest = "numeric_value" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in TraceMetricsRuleTraceFilterSpanTag. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + TraceMetricsRuleTraceFilterSpanTag.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + TraceMetricsRuleTraceFilterSpanTag.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + key: str, + numeric_value: Optional['outputs.TraceMetricsRuleTraceFilterSpanTagNumericValue'] = None, + value: Optional['outputs.TraceMetricsRuleTraceFilterSpanTagValue'] = None): + pulumi.set(__self__, "key", key) + if numeric_value is not None: + pulumi.set(__self__, "numeric_value", numeric_value) + if value is not None: + pulumi.set(__self__, "value", value) + + @property + @pulumi.getter + def key(self) -> str: + return pulumi.get(self, "key") + + @property + @pulumi.getter(name="numericValue") + def numeric_value(self) -> Optional['outputs.TraceMetricsRuleTraceFilterSpanTagNumericValue']: + return pulumi.get(self, "numeric_value") + + @property + @pulumi.getter + def value(self) -> Optional['outputs.TraceMetricsRuleTraceFilterSpanTagValue']: + return pulumi.get(self, "value") + + +@pulumi.output_type +class TraceMetricsRuleTraceFilterSpanTagNumericValue(dict): + def __init__(__self__, *, + comparison: str, + value: float): + pulumi.set(__self__, "comparison", comparison) + pulumi.set(__self__, "value", value) + + @property + @pulumi.getter + def comparison(self) -> str: + return pulumi.get(self, "comparison") + + @property + @pulumi.getter + def value(self) -> float: + return pulumi.get(self, "value") + + +@pulumi.output_type +class TraceMetricsRuleTraceFilterSpanTagValue(dict): + def __init__(__self__, *, + value: str, + match: Optional[str] = None): + pulumi.set(__self__, "value", value) + if match is not None: + pulumi.set(__self__, "match", match) + + @property + @pulumi.getter + def value(self) -> str: + return pulumi.get(self, "value") + + @property + @pulumi.getter + def match(self) -> Optional[str]: + return pulumi.get(self, "match") + + +@pulumi.output_type +class TraceMetricsRuleTraceFilterTrace(dict): + def __init__(__self__, *, + duration: Optional['outputs.TraceMetricsRuleTraceFilterTraceDuration'] = None, + error: Optional['outputs.TraceMetricsRuleTraceFilterTraceError'] = None): + if duration is not None: + pulumi.set(__self__, "duration", duration) + if error is not None: + pulumi.set(__self__, "error", error) + + @property + @pulumi.getter + def duration(self) -> Optional['outputs.TraceMetricsRuleTraceFilterTraceDuration']: + return pulumi.get(self, "duration") + + @property + @pulumi.getter + def error(self) -> Optional['outputs.TraceMetricsRuleTraceFilterTraceError']: + return pulumi.get(self, "error") + + +@pulumi.output_type +class TraceMetricsRuleTraceFilterTraceDuration(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "maxSeconds": + suggest = "max_seconds" + elif key == "minSeconds": + suggest = "min_seconds" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in TraceMetricsRuleTraceFilterTraceDuration. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + TraceMetricsRuleTraceFilterTraceDuration.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + TraceMetricsRuleTraceFilterTraceDuration.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + max_seconds: Optional[float] = None, + min_seconds: Optional[float] = None): + if max_seconds is not None: + pulumi.set(__self__, "max_seconds", max_seconds) + if min_seconds is not None: + pulumi.set(__self__, "min_seconds", min_seconds) + + @property + @pulumi.getter(name="maxSeconds") + def max_seconds(self) -> Optional[float]: + return pulumi.get(self, "max_seconds") + + @property + @pulumi.getter(name="minSeconds") + def min_seconds(self) -> Optional[float]: + return pulumi.get(self, "min_seconds") + + +@pulumi.output_type +class TraceMetricsRuleTraceFilterTraceError(dict): + def __init__(__self__, *, + value: bool): + pulumi.set(__self__, "value", value) + + @property + @pulumi.getter + def value(self) -> bool: + return pulumi.get(self, "value") + + +@pulumi.output_type +class TraceTailSamplingRulesDefaultSampleRate(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "sampleRate": + suggest = "sample_rate" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in TraceTailSamplingRulesDefaultSampleRate. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + TraceTailSamplingRulesDefaultSampleRate.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + TraceTailSamplingRulesDefaultSampleRate.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + sample_rate: float, + enabled: Optional[bool] = None): + pulumi.set(__self__, "sample_rate", sample_rate) + if enabled is not None: + pulumi.set(__self__, "enabled", enabled) + + @property + @pulumi.getter(name="sampleRate") + def sample_rate(self) -> float: + return pulumi.get(self, "sample_rate") + + @property + @pulumi.getter + def enabled(self) -> Optional[bool]: + return pulumi.get(self, "enabled") + + +@pulumi.output_type +class TraceTailSamplingRulesRule(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "sampleRate": + suggest = "sample_rate" + elif key == "systemName": + suggest = "system_name" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in TraceTailSamplingRulesRule. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + TraceTailSamplingRulesRule.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + TraceTailSamplingRulesRule.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + filter: 'outputs.TraceTailSamplingRulesRuleFilter', + sample_rate: float, + name: Optional[str] = None, + system_name: Optional[str] = None): + pulumi.set(__self__, "filter", filter) + pulumi.set(__self__, "sample_rate", sample_rate) + if name is not None: + pulumi.set(__self__, "name", name) + if system_name is not None: + pulumi.set(__self__, "system_name", system_name) + + @property + @pulumi.getter + def filter(self) -> 'outputs.TraceTailSamplingRulesRuleFilter': + return pulumi.get(self, "filter") + + @property + @pulumi.getter(name="sampleRate") + def sample_rate(self) -> float: + return pulumi.get(self, "sample_rate") + + @property + @pulumi.getter + def name(self) -> Optional[str]: + return pulumi.get(self, "name") + + @property + @pulumi.getter(name="systemName") + def system_name(self) -> Optional[str]: + return pulumi.get(self, "system_name") + + +@pulumi.output_type +class TraceTailSamplingRulesRuleFilter(dict): + def __init__(__self__, *, + spans: Optional[Sequence['outputs.TraceTailSamplingRulesRuleFilterSpan']] = None, + trace: Optional['outputs.TraceTailSamplingRulesRuleFilterTrace'] = None): + if spans is not None: + pulumi.set(__self__, "spans", spans) + if trace is not None: + pulumi.set(__self__, "trace", trace) + + @property + @pulumi.getter + def spans(self) -> Optional[Sequence['outputs.TraceTailSamplingRulesRuleFilterSpan']]: + return pulumi.get(self, "spans") + + @property + @pulumi.getter + def trace(self) -> Optional['outputs.TraceTailSamplingRulesRuleFilterTrace']: + return pulumi.get(self, "trace") + + +@pulumi.output_type +class TraceTailSamplingRulesRuleFilterSpan(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "matchType": + suggest = "match_type" + elif key == "parentOperation": + suggest = "parent_operation" + elif key == "parentService": + suggest = "parent_service" + elif key == "spanCount": + suggest = "span_count" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in TraceTailSamplingRulesRuleFilterSpan. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + TraceTailSamplingRulesRuleFilterSpan.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + TraceTailSamplingRulesRuleFilterSpan.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + duration: Optional['outputs.TraceTailSamplingRulesRuleFilterSpanDuration'] = None, + error: Optional['outputs.TraceTailSamplingRulesRuleFilterSpanError'] = None, + match_type: Optional[str] = None, + operation: Optional['outputs.TraceTailSamplingRulesRuleFilterSpanOperation'] = None, + parent_operation: Optional['outputs.TraceTailSamplingRulesRuleFilterSpanParentOperation'] = None, + parent_service: Optional['outputs.TraceTailSamplingRulesRuleFilterSpanParentService'] = None, + service: Optional['outputs.TraceTailSamplingRulesRuleFilterSpanService'] = None, + span_count: Optional['outputs.TraceTailSamplingRulesRuleFilterSpanSpanCount'] = None, + tags: Optional[Sequence['outputs.TraceTailSamplingRulesRuleFilterSpanTag']] = None): + if duration is not None: + pulumi.set(__self__, "duration", duration) + if error is not None: + pulumi.set(__self__, "error", error) + if match_type is not None: + pulumi.set(__self__, "match_type", match_type) + if operation is not None: + pulumi.set(__self__, "operation", operation) + if parent_operation is not None: + pulumi.set(__self__, "parent_operation", parent_operation) + if parent_service is not None: + pulumi.set(__self__, "parent_service", parent_service) + if service is not None: + pulumi.set(__self__, "service", service) + if span_count is not None: + pulumi.set(__self__, "span_count", span_count) + if tags is not None: + pulumi.set(__self__, "tags", tags) + + @property + @pulumi.getter + def duration(self) -> Optional['outputs.TraceTailSamplingRulesRuleFilterSpanDuration']: + return pulumi.get(self, "duration") + + @property + @pulumi.getter + def error(self) -> Optional['outputs.TraceTailSamplingRulesRuleFilterSpanError']: + return pulumi.get(self, "error") + + @property + @pulumi.getter(name="matchType") + def match_type(self) -> Optional[str]: + return pulumi.get(self, "match_type") + + @property + @pulumi.getter + def operation(self) -> Optional['outputs.TraceTailSamplingRulesRuleFilterSpanOperation']: + return pulumi.get(self, "operation") + + @property + @pulumi.getter(name="parentOperation") + def parent_operation(self) -> Optional['outputs.TraceTailSamplingRulesRuleFilterSpanParentOperation']: + return pulumi.get(self, "parent_operation") + + @property + @pulumi.getter(name="parentService") + def parent_service(self) -> Optional['outputs.TraceTailSamplingRulesRuleFilterSpanParentService']: + return pulumi.get(self, "parent_service") + + @property + @pulumi.getter + def service(self) -> Optional['outputs.TraceTailSamplingRulesRuleFilterSpanService']: + return pulumi.get(self, "service") + + @property + @pulumi.getter(name="spanCount") + def span_count(self) -> Optional['outputs.TraceTailSamplingRulesRuleFilterSpanSpanCount']: + return pulumi.get(self, "span_count") + + @property + @pulumi.getter + def tags(self) -> Optional[Sequence['outputs.TraceTailSamplingRulesRuleFilterSpanTag']]: + return pulumi.get(self, "tags") + + +@pulumi.output_type +class TraceTailSamplingRulesRuleFilterSpanDuration(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "maxSecs": + suggest = "max_secs" + elif key == "minSecs": + suggest = "min_secs" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in TraceTailSamplingRulesRuleFilterSpanDuration. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + TraceTailSamplingRulesRuleFilterSpanDuration.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + TraceTailSamplingRulesRuleFilterSpanDuration.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + max_secs: Optional[float] = None, + min_secs: Optional[float] = None): + if max_secs is not None: + pulumi.set(__self__, "max_secs", max_secs) + if min_secs is not None: + pulumi.set(__self__, "min_secs", min_secs) + + @property + @pulumi.getter(name="maxSecs") + def max_secs(self) -> Optional[float]: + return pulumi.get(self, "max_secs") + + @property + @pulumi.getter(name="minSecs") + def min_secs(self) -> Optional[float]: + return pulumi.get(self, "min_secs") + + +@pulumi.output_type +class TraceTailSamplingRulesRuleFilterSpanError(dict): + def __init__(__self__, *, + value: bool): + pulumi.set(__self__, "value", value) + + @property + @pulumi.getter + def value(self) -> bool: + return pulumi.get(self, "value") + + +@pulumi.output_type +class TraceTailSamplingRulesRuleFilterSpanOperation(dict): + def __init__(__self__, *, + value: str, + match: Optional[str] = None): + pulumi.set(__self__, "value", value) + if match is not None: + pulumi.set(__self__, "match", match) + + @property + @pulumi.getter + def value(self) -> str: + return pulumi.get(self, "value") + + @property + @pulumi.getter + def match(self) -> Optional[str]: + return pulumi.get(self, "match") + + +@pulumi.output_type +class TraceTailSamplingRulesRuleFilterSpanParentOperation(dict): + def __init__(__self__, *, + value: str, + match: Optional[str] = None): + pulumi.set(__self__, "value", value) + if match is not None: + pulumi.set(__self__, "match", match) + + @property + @pulumi.getter + def value(self) -> str: + return pulumi.get(self, "value") + + @property + @pulumi.getter + def match(self) -> Optional[str]: + return pulumi.get(self, "match") + + +@pulumi.output_type +class TraceTailSamplingRulesRuleFilterSpanParentService(dict): + def __init__(__self__, *, + value: str, + match: Optional[str] = None): + pulumi.set(__self__, "value", value) + if match is not None: + pulumi.set(__self__, "match", match) + + @property + @pulumi.getter + def value(self) -> str: + return pulumi.get(self, "value") + + @property + @pulumi.getter + def match(self) -> Optional[str]: + return pulumi.get(self, "match") + + +@pulumi.output_type +class TraceTailSamplingRulesRuleFilterSpanService(dict): + def __init__(__self__, *, + value: str, + match: Optional[str] = None): + pulumi.set(__self__, "value", value) + if match is not None: + pulumi.set(__self__, "match", match) + + @property + @pulumi.getter + def value(self) -> str: + return pulumi.get(self, "value") + + @property + @pulumi.getter + def match(self) -> Optional[str]: + return pulumi.get(self, "match") + + +@pulumi.output_type +class TraceTailSamplingRulesRuleFilterSpanSpanCount(dict): + def __init__(__self__, *, + max: Optional[int] = None, + min: Optional[int] = None): + if max is not None: + pulumi.set(__self__, "max", max) + if min is not None: + pulumi.set(__self__, "min", min) + + @property + @pulumi.getter + def max(self) -> Optional[int]: + return pulumi.get(self, "max") + + @property + @pulumi.getter + def min(self) -> Optional[int]: + return pulumi.get(self, "min") + + +@pulumi.output_type +class TraceTailSamplingRulesRuleFilterSpanTag(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "numericValue": + suggest = "numeric_value" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in TraceTailSamplingRulesRuleFilterSpanTag. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + TraceTailSamplingRulesRuleFilterSpanTag.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + TraceTailSamplingRulesRuleFilterSpanTag.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + key: Optional[str] = None, + numeric_value: Optional['outputs.TraceTailSamplingRulesRuleFilterSpanTagNumericValue'] = None, + value: Optional['outputs.TraceTailSamplingRulesRuleFilterSpanTagValue'] = None): + if key is not None: + pulumi.set(__self__, "key", key) + if numeric_value is not None: + pulumi.set(__self__, "numeric_value", numeric_value) + if value is not None: + pulumi.set(__self__, "value", value) + + @property + @pulumi.getter + def key(self) -> Optional[str]: + return pulumi.get(self, "key") + + @property + @pulumi.getter(name="numericValue") + def numeric_value(self) -> Optional['outputs.TraceTailSamplingRulesRuleFilterSpanTagNumericValue']: + return pulumi.get(self, "numeric_value") + + @property + @pulumi.getter + def value(self) -> Optional['outputs.TraceTailSamplingRulesRuleFilterSpanTagValue']: + return pulumi.get(self, "value") + + +@pulumi.output_type +class TraceTailSamplingRulesRuleFilterSpanTagNumericValue(dict): + def __init__(__self__, *, + comparison: str, + value: float): + pulumi.set(__self__, "comparison", comparison) + pulumi.set(__self__, "value", value) + + @property + @pulumi.getter + def comparison(self) -> str: + return pulumi.get(self, "comparison") + + @property + @pulumi.getter + def value(self) -> float: + return pulumi.get(self, "value") + + +@pulumi.output_type +class TraceTailSamplingRulesRuleFilterSpanTagValue(dict): + def __init__(__self__, *, + value: str, + match: Optional[str] = None): + pulumi.set(__self__, "value", value) + if match is not None: + pulumi.set(__self__, "match", match) + + @property + @pulumi.getter + def value(self) -> str: + return pulumi.get(self, "value") + + @property + @pulumi.getter + def match(self) -> Optional[str]: + return pulumi.get(self, "match") + + +@pulumi.output_type +class TraceTailSamplingRulesRuleFilterTrace(dict): + def __init__(__self__, *, + duration: Optional['outputs.TraceTailSamplingRulesRuleFilterTraceDuration'] = None, + error: Optional['outputs.TraceTailSamplingRulesRuleFilterTraceError'] = None): + if duration is not None: + pulumi.set(__self__, "duration", duration) + if error is not None: + pulumi.set(__self__, "error", error) + + @property + @pulumi.getter + def duration(self) -> Optional['outputs.TraceTailSamplingRulesRuleFilterTraceDuration']: + return pulumi.get(self, "duration") + + @property + @pulumi.getter + def error(self) -> Optional['outputs.TraceTailSamplingRulesRuleFilterTraceError']: + return pulumi.get(self, "error") + + +@pulumi.output_type +class TraceTailSamplingRulesRuleFilterTraceDuration(dict): + @staticmethod + def __key_warning(key: str): + suggest = None + if key == "maxSecs": + suggest = "max_secs" + elif key == "minSecs": + suggest = "min_secs" + + if suggest: + pulumi.log.warn(f"Key '{key}' not found in TraceTailSamplingRulesRuleFilterTraceDuration. Access the value via the '{suggest}' property getter instead.") + + def __getitem__(self, key: str) -> Any: + TraceTailSamplingRulesRuleFilterTraceDuration.__key_warning(key) + return super().__getitem__(key) + + def get(self, key: str, default = None) -> Any: + TraceTailSamplingRulesRuleFilterTraceDuration.__key_warning(key) + return super().get(key, default) + + def __init__(__self__, *, + max_secs: Optional[float] = None, + min_secs: Optional[float] = None): + if max_secs is not None: + pulumi.set(__self__, "max_secs", max_secs) + if min_secs is not None: + pulumi.set(__self__, "min_secs", min_secs) + + @property + @pulumi.getter(name="maxSecs") + def max_secs(self) -> Optional[float]: + return pulumi.get(self, "max_secs") + + @property + @pulumi.getter(name="minSecs") + def min_secs(self) -> Optional[float]: + return pulumi.get(self, "min_secs") + + +@pulumi.output_type +class TraceTailSamplingRulesRuleFilterTraceError(dict): + def __init__(__self__, *, + value: bool): + pulumi.set(__self__, "value", value) + + @property + @pulumi.getter + def value(self) -> bool: + return pulumi.get(self, "value") + + diff --git a/sdk/python/chronosphereio_chronosphere/pagerduty_alert_notifier.py b/sdk/python/chronosphereio_chronosphere/pagerduty_alert_notifier.py new file mode 100644 index 00000000..4c8c2f4d --- /dev/null +++ b/sdk/python/chronosphereio_chronosphere/pagerduty_alert_notifier.py @@ -0,0 +1,817 @@ +# coding=utf-8 +# *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import copy +import warnings +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +from . import _utilities +from . import outputs +from ._inputs import * + +__all__ = ['PagerdutyAlertNotifierArgs', 'PagerdutyAlertNotifier'] + +@pulumi.input_type +class PagerdutyAlertNotifierArgs: + def __init__(__self__, *, + name: pulumi.Input[str], + severity: pulumi.Input[str], + url: pulumi.Input[str], + basic_auth_password: Optional[pulumi.Input[str]] = None, + basic_auth_username: Optional[pulumi.Input[str]] = None, + bearer_token: Optional[pulumi.Input[str]] = None, + class_: Optional[pulumi.Input[str]] = None, + client: Optional[pulumi.Input[str]] = None, + client_url: Optional[pulumi.Input[str]] = None, + component: Optional[pulumi.Input[str]] = None, + description: Optional[pulumi.Input[str]] = None, + details: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None, + group: Optional[pulumi.Input[str]] = None, + images: Optional[pulumi.Input[Sequence[pulumi.Input['PagerdutyAlertNotifierImageArgs']]]] = None, + links: Optional[pulumi.Input[Sequence[pulumi.Input['PagerdutyAlertNotifierLinkArgs']]]] = None, + proxy_url: Optional[pulumi.Input[str]] = None, + routing_key: Optional[pulumi.Input[str]] = None, + send_resolved: Optional[pulumi.Input[bool]] = None, + service_key: Optional[pulumi.Input[str]] = None, + slug: Optional[pulumi.Input[str]] = None, + tls_insecure_skip_verify: Optional[pulumi.Input[bool]] = None): + """ + The set of arguments for constructing a PagerdutyAlertNotifier resource. + """ + pulumi.set(__self__, "name", name) + pulumi.set(__self__, "severity", severity) + pulumi.set(__self__, "url", url) + if basic_auth_password is not None: + pulumi.set(__self__, "basic_auth_password", basic_auth_password) + if basic_auth_username is not None: + pulumi.set(__self__, "basic_auth_username", basic_auth_username) + if bearer_token is not None: + pulumi.set(__self__, "bearer_token", bearer_token) + if class_ is not None: + pulumi.set(__self__, "class_", class_) + if client is not None: + pulumi.set(__self__, "client", client) + if client_url is not None: + pulumi.set(__self__, "client_url", client_url) + if component is not None: + pulumi.set(__self__, "component", component) + if description is not None: + pulumi.set(__self__, "description", description) + if details is not None: + pulumi.set(__self__, "details", details) + if group is not None: + pulumi.set(__self__, "group", group) + if images is not None: + pulumi.set(__self__, "images", images) + if links is not None: + pulumi.set(__self__, "links", links) + if proxy_url is not None: + pulumi.set(__self__, "proxy_url", proxy_url) + if routing_key is not None: + pulumi.set(__self__, "routing_key", routing_key) + if send_resolved is not None: + pulumi.set(__self__, "send_resolved", send_resolved) + if service_key is not None: + pulumi.set(__self__, "service_key", service_key) + if slug is not None: + pulumi.set(__self__, "slug", slug) + if tls_insecure_skip_verify is not None: + pulumi.set(__self__, "tls_insecure_skip_verify", tls_insecure_skip_verify) + + @property + @pulumi.getter + def name(self) -> pulumi.Input[str]: + return pulumi.get(self, "name") + + @name.setter + def name(self, value: pulumi.Input[str]): + pulumi.set(self, "name", value) + + @property + @pulumi.getter + def severity(self) -> pulumi.Input[str]: + return pulumi.get(self, "severity") + + @severity.setter + def severity(self, value: pulumi.Input[str]): + pulumi.set(self, "severity", value) + + @property + @pulumi.getter + def url(self) -> pulumi.Input[str]: + return pulumi.get(self, "url") + + @url.setter + def url(self, value: pulumi.Input[str]): + pulumi.set(self, "url", value) + + @property + @pulumi.getter(name="basicAuthPassword") + def basic_auth_password(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "basic_auth_password") + + @basic_auth_password.setter + def basic_auth_password(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "basic_auth_password", value) + + @property + @pulumi.getter(name="basicAuthUsername") + def basic_auth_username(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "basic_auth_username") + + @basic_auth_username.setter + def basic_auth_username(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "basic_auth_username", value) + + @property + @pulumi.getter(name="bearerToken") + def bearer_token(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "bearer_token") + + @bearer_token.setter + def bearer_token(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "bearer_token", value) + + @property + @pulumi.getter(name="class") + def class_(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "class_") + + @class_.setter + def class_(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "class_", value) + + @property + @pulumi.getter + def client(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "client") + + @client.setter + def client(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "client", value) + + @property + @pulumi.getter(name="clientUrl") + def client_url(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "client_url") + + @client_url.setter + def client_url(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "client_url", value) + + @property + @pulumi.getter + def component(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "component") + + @component.setter + def component(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "component", value) + + @property + @pulumi.getter + def description(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "description") + + @description.setter + def description(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "description", value) + + @property + @pulumi.getter + def details(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]: + return pulumi.get(self, "details") + + @details.setter + def details(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]): + pulumi.set(self, "details", value) + + @property + @pulumi.getter + def group(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "group") + + @group.setter + def group(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "group", value) + + @property + @pulumi.getter + def images(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['PagerdutyAlertNotifierImageArgs']]]]: + return pulumi.get(self, "images") + + @images.setter + def images(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['PagerdutyAlertNotifierImageArgs']]]]): + pulumi.set(self, "images", value) + + @property + @pulumi.getter + def links(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['PagerdutyAlertNotifierLinkArgs']]]]: + return pulumi.get(self, "links") + + @links.setter + def links(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['PagerdutyAlertNotifierLinkArgs']]]]): + pulumi.set(self, "links", value) + + @property + @pulumi.getter(name="proxyUrl") + def proxy_url(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "proxy_url") + + @proxy_url.setter + def proxy_url(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "proxy_url", value) + + @property + @pulumi.getter(name="routingKey") + def routing_key(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "routing_key") + + @routing_key.setter + def routing_key(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "routing_key", value) + + @property + @pulumi.getter(name="sendResolved") + def send_resolved(self) -> Optional[pulumi.Input[bool]]: + return pulumi.get(self, "send_resolved") + + @send_resolved.setter + def send_resolved(self, value: Optional[pulumi.Input[bool]]): + pulumi.set(self, "send_resolved", value) + + @property + @pulumi.getter(name="serviceKey") + def service_key(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "service_key") + + @service_key.setter + def service_key(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "service_key", value) + + @property + @pulumi.getter + def slug(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "slug") + + @slug.setter + def slug(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "slug", value) + + @property + @pulumi.getter(name="tlsInsecureSkipVerify") + def tls_insecure_skip_verify(self) -> Optional[pulumi.Input[bool]]: + return pulumi.get(self, "tls_insecure_skip_verify") + + @tls_insecure_skip_verify.setter + def tls_insecure_skip_verify(self, value: Optional[pulumi.Input[bool]]): + pulumi.set(self, "tls_insecure_skip_verify", value) + + +@pulumi.input_type +class _PagerdutyAlertNotifierState: + def __init__(__self__, *, + basic_auth_password: Optional[pulumi.Input[str]] = None, + basic_auth_username: Optional[pulumi.Input[str]] = None, + bearer_token: Optional[pulumi.Input[str]] = None, + class_: Optional[pulumi.Input[str]] = None, + client: Optional[pulumi.Input[str]] = None, + client_url: Optional[pulumi.Input[str]] = None, + component: Optional[pulumi.Input[str]] = None, + description: Optional[pulumi.Input[str]] = None, + details: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None, + group: Optional[pulumi.Input[str]] = None, + images: Optional[pulumi.Input[Sequence[pulumi.Input['PagerdutyAlertNotifierImageArgs']]]] = None, + links: Optional[pulumi.Input[Sequence[pulumi.Input['PagerdutyAlertNotifierLinkArgs']]]] = None, + name: Optional[pulumi.Input[str]] = None, + proxy_url: Optional[pulumi.Input[str]] = None, + routing_key: Optional[pulumi.Input[str]] = None, + send_resolved: Optional[pulumi.Input[bool]] = None, + service_key: Optional[pulumi.Input[str]] = None, + severity: Optional[pulumi.Input[str]] = None, + slug: Optional[pulumi.Input[str]] = None, + tls_insecure_skip_verify: Optional[pulumi.Input[bool]] = None, + url: Optional[pulumi.Input[str]] = None): + """ + Input properties used for looking up and filtering PagerdutyAlertNotifier resources. + """ + if basic_auth_password is not None: + pulumi.set(__self__, "basic_auth_password", basic_auth_password) + if basic_auth_username is not None: + pulumi.set(__self__, "basic_auth_username", basic_auth_username) + if bearer_token is not None: + pulumi.set(__self__, "bearer_token", bearer_token) + if class_ is not None: + pulumi.set(__self__, "class_", class_) + if client is not None: + pulumi.set(__self__, "client", client) + if client_url is not None: + pulumi.set(__self__, "client_url", client_url) + if component is not None: + pulumi.set(__self__, "component", component) + if description is not None: + pulumi.set(__self__, "description", description) + if details is not None: + pulumi.set(__self__, "details", details) + if group is not None: + pulumi.set(__self__, "group", group) + if images is not None: + pulumi.set(__self__, "images", images) + if links is not None: + pulumi.set(__self__, "links", links) + if name is not None: + pulumi.set(__self__, "name", name) + if proxy_url is not None: + pulumi.set(__self__, "proxy_url", proxy_url) + if routing_key is not None: + pulumi.set(__self__, "routing_key", routing_key) + if send_resolved is not None: + pulumi.set(__self__, "send_resolved", send_resolved) + if service_key is not None: + pulumi.set(__self__, "service_key", service_key) + if severity is not None: + pulumi.set(__self__, "severity", severity) + if slug is not None: + pulumi.set(__self__, "slug", slug) + if tls_insecure_skip_verify is not None: + pulumi.set(__self__, "tls_insecure_skip_verify", tls_insecure_skip_verify) + if url is not None: + pulumi.set(__self__, "url", url) + + @property + @pulumi.getter(name="basicAuthPassword") + def basic_auth_password(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "basic_auth_password") + + @basic_auth_password.setter + def basic_auth_password(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "basic_auth_password", value) + + @property + @pulumi.getter(name="basicAuthUsername") + def basic_auth_username(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "basic_auth_username") + + @basic_auth_username.setter + def basic_auth_username(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "basic_auth_username", value) + + @property + @pulumi.getter(name="bearerToken") + def bearer_token(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "bearer_token") + + @bearer_token.setter + def bearer_token(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "bearer_token", value) + + @property + @pulumi.getter(name="class") + def class_(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "class_") + + @class_.setter + def class_(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "class_", value) + + @property + @pulumi.getter + def client(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "client") + + @client.setter + def client(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "client", value) + + @property + @pulumi.getter(name="clientUrl") + def client_url(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "client_url") + + @client_url.setter + def client_url(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "client_url", value) + + @property + @pulumi.getter + def component(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "component") + + @component.setter + def component(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "component", value) + + @property + @pulumi.getter + def description(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "description") + + @description.setter + def description(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "description", value) + + @property + @pulumi.getter + def details(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]: + return pulumi.get(self, "details") + + @details.setter + def details(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]): + pulumi.set(self, "details", value) + + @property + @pulumi.getter + def group(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "group") + + @group.setter + def group(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "group", value) + + @property + @pulumi.getter + def images(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['PagerdutyAlertNotifierImageArgs']]]]: + return pulumi.get(self, "images") + + @images.setter + def images(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['PagerdutyAlertNotifierImageArgs']]]]): + pulumi.set(self, "images", value) + + @property + @pulumi.getter + def links(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['PagerdutyAlertNotifierLinkArgs']]]]: + return pulumi.get(self, "links") + + @links.setter + def links(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['PagerdutyAlertNotifierLinkArgs']]]]): + pulumi.set(self, "links", value) + + @property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "name", value) + + @property + @pulumi.getter(name="proxyUrl") + def proxy_url(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "proxy_url") + + @proxy_url.setter + def proxy_url(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "proxy_url", value) + + @property + @pulumi.getter(name="routingKey") + def routing_key(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "routing_key") + + @routing_key.setter + def routing_key(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "routing_key", value) + + @property + @pulumi.getter(name="sendResolved") + def send_resolved(self) -> Optional[pulumi.Input[bool]]: + return pulumi.get(self, "send_resolved") + + @send_resolved.setter + def send_resolved(self, value: Optional[pulumi.Input[bool]]): + pulumi.set(self, "send_resolved", value) + + @property + @pulumi.getter(name="serviceKey") + def service_key(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "service_key") + + @service_key.setter + def service_key(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "service_key", value) + + @property + @pulumi.getter + def severity(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "severity") + + @severity.setter + def severity(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "severity", value) + + @property + @pulumi.getter + def slug(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "slug") + + @slug.setter + def slug(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "slug", value) + + @property + @pulumi.getter(name="tlsInsecureSkipVerify") + def tls_insecure_skip_verify(self) -> Optional[pulumi.Input[bool]]: + return pulumi.get(self, "tls_insecure_skip_verify") + + @tls_insecure_skip_verify.setter + def tls_insecure_skip_verify(self, value: Optional[pulumi.Input[bool]]): + pulumi.set(self, "tls_insecure_skip_verify", value) + + @property + @pulumi.getter + def url(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "url") + + @url.setter + def url(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "url", value) + + +class PagerdutyAlertNotifier(pulumi.CustomResource): + @overload + def __init__(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + basic_auth_password: Optional[pulumi.Input[str]] = None, + basic_auth_username: Optional[pulumi.Input[str]] = None, + bearer_token: Optional[pulumi.Input[str]] = None, + class_: Optional[pulumi.Input[str]] = None, + client: Optional[pulumi.Input[str]] = None, + client_url: Optional[pulumi.Input[str]] = None, + component: Optional[pulumi.Input[str]] = None, + description: Optional[pulumi.Input[str]] = None, + details: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None, + group: Optional[pulumi.Input[str]] = None, + images: Optional[pulumi.Input[Sequence[pulumi.Input[pulumi.InputType['PagerdutyAlertNotifierImageArgs']]]]] = None, + links: Optional[pulumi.Input[Sequence[pulumi.Input[pulumi.InputType['PagerdutyAlertNotifierLinkArgs']]]]] = None, + name: Optional[pulumi.Input[str]] = None, + proxy_url: Optional[pulumi.Input[str]] = None, + routing_key: Optional[pulumi.Input[str]] = None, + send_resolved: Optional[pulumi.Input[bool]] = None, + service_key: Optional[pulumi.Input[str]] = None, + severity: Optional[pulumi.Input[str]] = None, + slug: Optional[pulumi.Input[str]] = None, + tls_insecure_skip_verify: Optional[pulumi.Input[bool]] = None, + url: Optional[pulumi.Input[str]] = None, + __props__=None): + """ + Create a PagerdutyAlertNotifier resource with the given unique name, props, and options. + :param str resource_name: The name of the resource. + :param pulumi.ResourceOptions opts: Options for the resource. + """ + ... + @overload + def __init__(__self__, + resource_name: str, + args: PagerdutyAlertNotifierArgs, + opts: Optional[pulumi.ResourceOptions] = None): + """ + Create a PagerdutyAlertNotifier resource with the given unique name, props, and options. + :param str resource_name: The name of the resource. + :param PagerdutyAlertNotifierArgs 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(PagerdutyAlertNotifierArgs, 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_password: Optional[pulumi.Input[str]] = None, + basic_auth_username: Optional[pulumi.Input[str]] = None, + bearer_token: Optional[pulumi.Input[str]] = None, + class_: Optional[pulumi.Input[str]] = None, + client: Optional[pulumi.Input[str]] = None, + client_url: Optional[pulumi.Input[str]] = None, + component: Optional[pulumi.Input[str]] = None, + description: Optional[pulumi.Input[str]] = None, + details: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None, + group: Optional[pulumi.Input[str]] = None, + images: Optional[pulumi.Input[Sequence[pulumi.Input[pulumi.InputType['PagerdutyAlertNotifierImageArgs']]]]] = None, + links: Optional[pulumi.Input[Sequence[pulumi.Input[pulumi.InputType['PagerdutyAlertNotifierLinkArgs']]]]] = None, + name: Optional[pulumi.Input[str]] = None, + proxy_url: Optional[pulumi.Input[str]] = None, + routing_key: Optional[pulumi.Input[str]] = None, + send_resolved: Optional[pulumi.Input[bool]] = None, + service_key: Optional[pulumi.Input[str]] = None, + severity: Optional[pulumi.Input[str]] = None, + slug: Optional[pulumi.Input[str]] = None, + tls_insecure_skip_verify: Optional[pulumi.Input[bool]] = None, + url: Optional[pulumi.Input[str]] = None, + __props__=None): + opts = pulumi.ResourceOptions.merge(_utilities.get_resource_opts_defaults(), opts) + if not isinstance(opts, pulumi.ResourceOptions): + raise TypeError('Expected resource options to be a ResourceOptions instance') + if opts.id is None: + if __props__ is not None: + raise TypeError('__props__ is only valid when passed in combination with a valid opts.id to get an existing resource') + __props__ = PagerdutyAlertNotifierArgs.__new__(PagerdutyAlertNotifierArgs) + + __props__.__dict__["basic_auth_password"] = None if basic_auth_password is None else pulumi.Output.secret(basic_auth_password) + __props__.__dict__["basic_auth_username"] = basic_auth_username + __props__.__dict__["bearer_token"] = bearer_token + __props__.__dict__["class_"] = class_ + __props__.__dict__["client"] = client + __props__.__dict__["client_url"] = client_url + __props__.__dict__["component"] = component + __props__.__dict__["description"] = description + __props__.__dict__["details"] = details + __props__.__dict__["group"] = group + __props__.__dict__["images"] = images + __props__.__dict__["links"] = links + if name is None and not opts.urn: + raise TypeError("Missing required property 'name'") + __props__.__dict__["name"] = name + __props__.__dict__["proxy_url"] = proxy_url + __props__.__dict__["routing_key"] = routing_key + __props__.__dict__["send_resolved"] = send_resolved + __props__.__dict__["service_key"] = None if service_key is None else pulumi.Output.secret(service_key) + if severity is None and not opts.urn: + raise TypeError("Missing required property 'severity'") + __props__.__dict__["severity"] = severity + __props__.__dict__["slug"] = slug + __props__.__dict__["tls_insecure_skip_verify"] = tls_insecure_skip_verify + if url is None and not opts.urn: + raise TypeError("Missing required property 'url'") + __props__.__dict__["url"] = url + secret_opts = pulumi.ResourceOptions(additional_secret_outputs=["basicAuthPassword", "serviceKey"]) + opts = pulumi.ResourceOptions.merge(opts, secret_opts) + super(PagerdutyAlertNotifier, __self__).__init__( + 'chronosphere:index/pagerdutyAlertNotifier:PagerdutyAlertNotifier', + resource_name, + __props__, + opts) + + @staticmethod + def get(resource_name: str, + id: pulumi.Input[str], + opts: Optional[pulumi.ResourceOptions] = None, + basic_auth_password: Optional[pulumi.Input[str]] = None, + basic_auth_username: Optional[pulumi.Input[str]] = None, + bearer_token: Optional[pulumi.Input[str]] = None, + class_: Optional[pulumi.Input[str]] = None, + client: Optional[pulumi.Input[str]] = None, + client_url: Optional[pulumi.Input[str]] = None, + component: Optional[pulumi.Input[str]] = None, + description: Optional[pulumi.Input[str]] = None, + details: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None, + group: Optional[pulumi.Input[str]] = None, + images: Optional[pulumi.Input[Sequence[pulumi.Input[pulumi.InputType['PagerdutyAlertNotifierImageArgs']]]]] = None, + links: Optional[pulumi.Input[Sequence[pulumi.Input[pulumi.InputType['PagerdutyAlertNotifierLinkArgs']]]]] = None, + name: Optional[pulumi.Input[str]] = None, + proxy_url: Optional[pulumi.Input[str]] = None, + routing_key: Optional[pulumi.Input[str]] = None, + send_resolved: Optional[pulumi.Input[bool]] = None, + service_key: Optional[pulumi.Input[str]] = None, + severity: Optional[pulumi.Input[str]] = None, + slug: Optional[pulumi.Input[str]] = None, + tls_insecure_skip_verify: Optional[pulumi.Input[bool]] = None, + url: Optional[pulumi.Input[str]] = None) -> 'PagerdutyAlertNotifier': + """ + Get an existing PagerdutyAlertNotifier 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. + """ + opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id)) + + __props__ = _PagerdutyAlertNotifierState.__new__(_PagerdutyAlertNotifierState) + + __props__.__dict__["basic_auth_password"] = basic_auth_password + __props__.__dict__["basic_auth_username"] = basic_auth_username + __props__.__dict__["bearer_token"] = bearer_token + __props__.__dict__["class_"] = class_ + __props__.__dict__["client"] = client + __props__.__dict__["client_url"] = client_url + __props__.__dict__["component"] = component + __props__.__dict__["description"] = description + __props__.__dict__["details"] = details + __props__.__dict__["group"] = group + __props__.__dict__["images"] = images + __props__.__dict__["links"] = links + __props__.__dict__["name"] = name + __props__.__dict__["proxy_url"] = proxy_url + __props__.__dict__["routing_key"] = routing_key + __props__.__dict__["send_resolved"] = send_resolved + __props__.__dict__["service_key"] = service_key + __props__.__dict__["severity"] = severity + __props__.__dict__["slug"] = slug + __props__.__dict__["tls_insecure_skip_verify"] = tls_insecure_skip_verify + __props__.__dict__["url"] = url + return PagerdutyAlertNotifier(resource_name, opts=opts, __props__=__props__) + + @property + @pulumi.getter(name="basicAuthPassword") + def basic_auth_password(self) -> pulumi.Output[Optional[str]]: + return pulumi.get(self, "basic_auth_password") + + @property + @pulumi.getter(name="basicAuthUsername") + def basic_auth_username(self) -> pulumi.Output[Optional[str]]: + return pulumi.get(self, "basic_auth_username") + + @property + @pulumi.getter(name="bearerToken") + def bearer_token(self) -> pulumi.Output[Optional[str]]: + return pulumi.get(self, "bearer_token") + + @property + @pulumi.getter(name="class") + def class_(self) -> pulumi.Output[Optional[str]]: + return pulumi.get(self, "class_") + + @property + @pulumi.getter + def client(self) -> pulumi.Output[Optional[str]]: + return pulumi.get(self, "client") + + @property + @pulumi.getter(name="clientUrl") + def client_url(self) -> pulumi.Output[Optional[str]]: + return pulumi.get(self, "client_url") + + @property + @pulumi.getter + def component(self) -> pulumi.Output[Optional[str]]: + return pulumi.get(self, "component") + + @property + @pulumi.getter + def description(self) -> pulumi.Output[Optional[str]]: + return pulumi.get(self, "description") + + @property + @pulumi.getter + def details(self) -> pulumi.Output[Optional[Mapping[str, str]]]: + return pulumi.get(self, "details") + + @property + @pulumi.getter + def group(self) -> pulumi.Output[Optional[str]]: + return pulumi.get(self, "group") + + @property + @pulumi.getter + def images(self) -> pulumi.Output[Optional[Sequence['outputs.PagerdutyAlertNotifierImage']]]: + return pulumi.get(self, "images") + + @property + @pulumi.getter + def links(self) -> pulumi.Output[Optional[Sequence['outputs.PagerdutyAlertNotifierLink']]]: + return pulumi.get(self, "links") + + @property + @pulumi.getter + def name(self) -> pulumi.Output[str]: + return pulumi.get(self, "name") + + @property + @pulumi.getter(name="proxyUrl") + def proxy_url(self) -> pulumi.Output[Optional[str]]: + return pulumi.get(self, "proxy_url") + + @property + @pulumi.getter(name="routingKey") + def routing_key(self) -> pulumi.Output[Optional[str]]: + return pulumi.get(self, "routing_key") + + @property + @pulumi.getter(name="sendResolved") + def send_resolved(self) -> pulumi.Output[Optional[bool]]: + return pulumi.get(self, "send_resolved") + + @property + @pulumi.getter(name="serviceKey") + def service_key(self) -> pulumi.Output[Optional[str]]: + return pulumi.get(self, "service_key") + + @property + @pulumi.getter + def severity(self) -> pulumi.Output[str]: + return pulumi.get(self, "severity") + + @property + @pulumi.getter + def slug(self) -> pulumi.Output[str]: + return pulumi.get(self, "slug") + + @property + @pulumi.getter(name="tlsInsecureSkipVerify") + def tls_insecure_skip_verify(self) -> pulumi.Output[Optional[bool]]: + return pulumi.get(self, "tls_insecure_skip_verify") + + @property + @pulumi.getter + def url(self) -> pulumi.Output[str]: + return pulumi.get(self, "url") + diff --git a/sdk/python/chronosphereio_chronosphere/provider.py b/sdk/python/chronosphereio_chronosphere/provider.py new file mode 100644 index 00000000..d5c0f8a5 --- /dev/null +++ b/sdk/python/chronosphereio_chronosphere/provider.py @@ -0,0 +1,163 @@ +# coding=utf-8 +# *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import copy +import warnings +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +from . import _utilities + +__all__ = ['ProviderArgs', 'Provider'] + +@pulumi.input_type +class ProviderArgs: + def __init__(__self__, *, + api_token: Optional[pulumi.Input[str]] = None, + entity_namespace: Optional[pulumi.Input[str]] = None, + org: Optional[pulumi.Input[str]] = None, + unstable: Optional[pulumi.Input[bool]] = None): + """ + The set of arguments for constructing a Provider resource. + """ + if api_token is None: + api_token = _utilities.get_env('CHRONOSPHERE_API_TOKEN') + if api_token is not None: + pulumi.set(__self__, "api_token", api_token) + if entity_namespace is not None: + pulumi.set(__self__, "entity_namespace", entity_namespace) + if org is None: + org = _utilities.get_env('CHRONOSPHERE_ORG', 'CHRONOSPHERE_ORG_NAME') + if org is not None: + pulumi.set(__self__, "org", org) + if unstable is not None: + pulumi.set(__self__, "unstable", unstable) + + @property + @pulumi.getter(name="apiToken") + def api_token(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "api_token") + + @api_token.setter + def api_token(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "api_token", value) + + @property + @pulumi.getter(name="entityNamespace") + def entity_namespace(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "entity_namespace") + + @entity_namespace.setter + def entity_namespace(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "entity_namespace", value) + + @property + @pulumi.getter + def org(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "org") + + @org.setter + def org(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "org", value) + + @property + @pulumi.getter + def unstable(self) -> Optional[pulumi.Input[bool]]: + return pulumi.get(self, "unstable") + + @unstable.setter + def unstable(self, value: Optional[pulumi.Input[bool]]): + pulumi.set(self, "unstable", value) + + +class Provider(pulumi.ProviderResource): + @overload + def __init__(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + api_token: Optional[pulumi.Input[str]] = None, + entity_namespace: Optional[pulumi.Input[str]] = None, + org: Optional[pulumi.Input[str]] = None, + unstable: Optional[pulumi.Input[bool]] = None, + __props__=None): + """ + The provider type for the chronosphere 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. + """ + ... + @overload + def __init__(__self__, + resource_name: str, + args: Optional[ProviderArgs] = None, + opts: Optional[pulumi.ResourceOptions] = None): + """ + The provider type for the chronosphere 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, + api_token: Optional[pulumi.Input[str]] = None, + entity_namespace: Optional[pulumi.Input[str]] = None, + org: Optional[pulumi.Input[str]] = None, + unstable: Optional[pulumi.Input[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__ = ProviderArgs.__new__(ProviderArgs) + + if api_token is None: + api_token = _utilities.get_env('CHRONOSPHERE_API_TOKEN') + __props__.__dict__["api_token"] = None if api_token is None else pulumi.Output.secret(api_token) + __props__.__dict__["entity_namespace"] = entity_namespace + if org is None: + org = _utilities.get_env('CHRONOSPHERE_ORG', 'CHRONOSPHERE_ORG_NAME') + __props__.__dict__["org"] = org + __props__.__dict__["unstable"] = pulumi.Output.from_input(unstable).apply(pulumi.runtime.to_json) if unstable is not None else None + secret_opts = pulumi.ResourceOptions(additional_secret_outputs=["apiToken"]) + opts = pulumi.ResourceOptions.merge(opts, secret_opts) + super(Provider, __self__).__init__( + 'chronosphere', + resource_name, + __props__, + opts) + + @property + @pulumi.getter(name="apiToken") + def api_token(self) -> pulumi.Output[Optional[str]]: + return pulumi.get(self, "api_token") + + @property + @pulumi.getter(name="entityNamespace") + def entity_namespace(self) -> pulumi.Output[Optional[str]]: + return pulumi.get(self, "entity_namespace") + + @property + @pulumi.getter + def org(self) -> pulumi.Output[Optional[str]]: + return pulumi.get(self, "org") + diff --git a/sdk/python/chronosphereio_chronosphere/pulumi-plugin.json b/sdk/python/chronosphereio_chronosphere/pulumi-plugin.json new file mode 100644 index 00000000..c466b59c --- /dev/null +++ b/sdk/python/chronosphereio_chronosphere/pulumi-plugin.json @@ -0,0 +1,4 @@ +{ + "resource": true, + "name": "chronosphere" +} diff --git a/sdk/python/chronosphereio_chronosphere/py.typed b/sdk/python/chronosphereio_chronosphere/py.typed new file mode 100644 index 00000000..e69de29b diff --git a/sdk/python/chronosphereio_chronosphere/recording_rule.py b/sdk/python/chronosphereio_chronosphere/recording_rule.py new file mode 100644 index 00000000..31b06d82 --- /dev/null +++ b/sdk/python/chronosphereio_chronosphere/recording_rule.py @@ -0,0 +1,370 @@ +# coding=utf-8 +# *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import copy +import warnings +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +from . import _utilities + +__all__ = ['RecordingRuleArgs', 'RecordingRule'] + +@pulumi.input_type +class RecordingRuleArgs: + def __init__(__self__, *, + expr: pulumi.Input[str], + name: pulumi.Input[str], + bucket_id: Optional[pulumi.Input[str]] = None, + execution_group: Optional[pulumi.Input[str]] = None, + interval: Optional[pulumi.Input[str]] = None, + labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None, + metric_name: Optional[pulumi.Input[str]] = None, + slug: Optional[pulumi.Input[str]] = None): + """ + The set of arguments for constructing a RecordingRule resource. + """ + pulumi.set(__self__, "expr", expr) + pulumi.set(__self__, "name", name) + if bucket_id is not None: + pulumi.set(__self__, "bucket_id", bucket_id) + if execution_group is not None: + pulumi.set(__self__, "execution_group", execution_group) + if interval is not None: + pulumi.set(__self__, "interval", interval) + if labels is not None: + pulumi.set(__self__, "labels", labels) + if metric_name is not None: + pulumi.set(__self__, "metric_name", metric_name) + if slug is not None: + pulumi.set(__self__, "slug", slug) + + @property + @pulumi.getter + def expr(self) -> pulumi.Input[str]: + return pulumi.get(self, "expr") + + @expr.setter + def expr(self, value: pulumi.Input[str]): + pulumi.set(self, "expr", value) + + @property + @pulumi.getter + def name(self) -> pulumi.Input[str]: + return pulumi.get(self, "name") + + @name.setter + def name(self, value: pulumi.Input[str]): + pulumi.set(self, "name", value) + + @property + @pulumi.getter(name="bucketId") + def bucket_id(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "bucket_id") + + @bucket_id.setter + def bucket_id(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "bucket_id", value) + + @property + @pulumi.getter(name="executionGroup") + def execution_group(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "execution_group") + + @execution_group.setter + def execution_group(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "execution_group", value) + + @property + @pulumi.getter + def interval(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "interval") + + @interval.setter + def interval(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "interval", value) + + @property + @pulumi.getter + def labels(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]: + return pulumi.get(self, "labels") + + @labels.setter + def labels(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]): + pulumi.set(self, "labels", value) + + @property + @pulumi.getter(name="metricName") + def metric_name(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "metric_name") + + @metric_name.setter + def metric_name(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "metric_name", value) + + @property + @pulumi.getter + def slug(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "slug") + + @slug.setter + def slug(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "slug", value) + + +@pulumi.input_type +class _RecordingRuleState: + def __init__(__self__, *, + bucket_id: Optional[pulumi.Input[str]] = None, + execution_group: Optional[pulumi.Input[str]] = None, + expr: Optional[pulumi.Input[str]] = None, + interval: Optional[pulumi.Input[str]] = None, + labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None, + metric_name: Optional[pulumi.Input[str]] = None, + name: Optional[pulumi.Input[str]] = None, + slug: Optional[pulumi.Input[str]] = None): + """ + Input properties used for looking up and filtering RecordingRule resources. + """ + if bucket_id is not None: + pulumi.set(__self__, "bucket_id", bucket_id) + if execution_group is not None: + pulumi.set(__self__, "execution_group", execution_group) + if expr is not None: + pulumi.set(__self__, "expr", expr) + if interval is not None: + pulumi.set(__self__, "interval", interval) + if labels is not None: + pulumi.set(__self__, "labels", labels) + if metric_name is not None: + pulumi.set(__self__, "metric_name", metric_name) + if name is not None: + pulumi.set(__self__, "name", name) + if slug is not None: + pulumi.set(__self__, "slug", slug) + + @property + @pulumi.getter(name="bucketId") + def bucket_id(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "bucket_id") + + @bucket_id.setter + def bucket_id(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "bucket_id", value) + + @property + @pulumi.getter(name="executionGroup") + def execution_group(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "execution_group") + + @execution_group.setter + def execution_group(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "execution_group", value) + + @property + @pulumi.getter + def expr(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "expr") + + @expr.setter + def expr(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "expr", value) + + @property + @pulumi.getter + def interval(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "interval") + + @interval.setter + def interval(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "interval", value) + + @property + @pulumi.getter + def labels(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]: + return pulumi.get(self, "labels") + + @labels.setter + def labels(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]): + pulumi.set(self, "labels", value) + + @property + @pulumi.getter(name="metricName") + def metric_name(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "metric_name") + + @metric_name.setter + def metric_name(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "metric_name", value) + + @property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "name", value) + + @property + @pulumi.getter + def slug(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "slug") + + @slug.setter + def slug(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "slug", value) + + +class RecordingRule(pulumi.CustomResource): + @overload + def __init__(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + bucket_id: Optional[pulumi.Input[str]] = None, + execution_group: Optional[pulumi.Input[str]] = None, + expr: Optional[pulumi.Input[str]] = None, + interval: Optional[pulumi.Input[str]] = None, + labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None, + metric_name: Optional[pulumi.Input[str]] = None, + name: Optional[pulumi.Input[str]] = None, + slug: Optional[pulumi.Input[str]] = None, + __props__=None): + """ + Create a RecordingRule resource with the given unique name, props, and options. + :param str resource_name: The name of the resource. + :param pulumi.ResourceOptions opts: Options for the resource. + """ + ... + @overload + def __init__(__self__, + resource_name: str, + args: RecordingRuleArgs, + opts: Optional[pulumi.ResourceOptions] = None): + """ + Create a RecordingRule resource with the given unique name, props, and options. + :param str resource_name: The name of the resource. + :param RecordingRuleArgs 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(RecordingRuleArgs, 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, + bucket_id: Optional[pulumi.Input[str]] = None, + execution_group: Optional[pulumi.Input[str]] = None, + expr: Optional[pulumi.Input[str]] = None, + interval: Optional[pulumi.Input[str]] = None, + labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None, + metric_name: Optional[pulumi.Input[str]] = None, + name: Optional[pulumi.Input[str]] = None, + slug: Optional[pulumi.Input[str]] = None, + __props__=None): + opts = pulumi.ResourceOptions.merge(_utilities.get_resource_opts_defaults(), opts) + if not isinstance(opts, pulumi.ResourceOptions): + raise TypeError('Expected resource options to be a ResourceOptions instance') + if opts.id is None: + if __props__ is not None: + raise TypeError('__props__ is only valid when passed in combination with a valid opts.id to get an existing resource') + __props__ = RecordingRuleArgs.__new__(RecordingRuleArgs) + + __props__.__dict__["bucket_id"] = bucket_id + __props__.__dict__["execution_group"] = execution_group + if expr is None and not opts.urn: + raise TypeError("Missing required property 'expr'") + __props__.__dict__["expr"] = expr + __props__.__dict__["interval"] = interval + __props__.__dict__["labels"] = labels + __props__.__dict__["metric_name"] = metric_name + if name is None and not opts.urn: + raise TypeError("Missing required property 'name'") + __props__.__dict__["name"] = name + __props__.__dict__["slug"] = slug + super(RecordingRule, __self__).__init__( + 'chronosphere:index/recordingRule:RecordingRule', + resource_name, + __props__, + opts) + + @staticmethod + def get(resource_name: str, + id: pulumi.Input[str], + opts: Optional[pulumi.ResourceOptions] = None, + bucket_id: Optional[pulumi.Input[str]] = None, + execution_group: Optional[pulumi.Input[str]] = None, + expr: Optional[pulumi.Input[str]] = None, + interval: Optional[pulumi.Input[str]] = None, + labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None, + metric_name: Optional[pulumi.Input[str]] = None, + name: Optional[pulumi.Input[str]] = None, + slug: Optional[pulumi.Input[str]] = None) -> 'RecordingRule': + """ + Get an existing RecordingRule 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. + """ + opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id)) + + __props__ = _RecordingRuleState.__new__(_RecordingRuleState) + + __props__.__dict__["bucket_id"] = bucket_id + __props__.__dict__["execution_group"] = execution_group + __props__.__dict__["expr"] = expr + __props__.__dict__["interval"] = interval + __props__.__dict__["labels"] = labels + __props__.__dict__["metric_name"] = metric_name + __props__.__dict__["name"] = name + __props__.__dict__["slug"] = slug + return RecordingRule(resource_name, opts=opts, __props__=__props__) + + @property + @pulumi.getter(name="bucketId") + def bucket_id(self) -> pulumi.Output[Optional[str]]: + return pulumi.get(self, "bucket_id") + + @property + @pulumi.getter(name="executionGroup") + def execution_group(self) -> pulumi.Output[Optional[str]]: + return pulumi.get(self, "execution_group") + + @property + @pulumi.getter + def expr(self) -> pulumi.Output[str]: + return pulumi.get(self, "expr") + + @property + @pulumi.getter + def interval(self) -> pulumi.Output[Optional[str]]: + return pulumi.get(self, "interval") + + @property + @pulumi.getter + def labels(self) -> pulumi.Output[Optional[Mapping[str, str]]]: + return pulumi.get(self, "labels") + + @property + @pulumi.getter(name="metricName") + def metric_name(self) -> pulumi.Output[Optional[str]]: + return pulumi.get(self, "metric_name") + + @property + @pulumi.getter + def name(self) -> pulumi.Output[str]: + return pulumi.get(self, "name") + + @property + @pulumi.getter + def slug(self) -> pulumi.Output[str]: + return pulumi.get(self, "slug") + diff --git a/sdk/python/chronosphereio_chronosphere/resource_pools_config.py b/sdk/python/chronosphereio_chronosphere/resource_pools_config.py new file mode 100644 index 00000000..dd0d5f32 --- /dev/null +++ b/sdk/python/chronosphereio_chronosphere/resource_pools_config.py @@ -0,0 +1,216 @@ +# coding=utf-8 +# *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import copy +import warnings +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +from . import _utilities +from . import outputs +from ._inputs import * + +__all__ = ['ResourcePoolsConfigArgs', 'ResourcePoolsConfig'] + +@pulumi.input_type +class ResourcePoolsConfigArgs: + def __init__(__self__, *, + default_pool: pulumi.Input['ResourcePoolsConfigDefaultPoolArgs'], + pool: Optional[pulumi.Input[Sequence[pulumi.Input['ResourcePoolsConfigPoolArgs']]]] = None, + pools: Optional[pulumi.Input[Sequence[pulumi.Input['ResourcePoolsConfigPoolArgs']]]] = None): + """ + The set of arguments for constructing a ResourcePoolsConfig resource. + """ + pulumi.set(__self__, "default_pool", default_pool) + if pool is not None: + pulumi.set(__self__, "pool", pool) + if pools is not None: + warnings.warn("""Use pool instead of pools""", DeprecationWarning) + pulumi.log.warn("""pools is deprecated: Use pool instead of pools""") + if pools is not None: + pulumi.set(__self__, "pools", pools) + + @property + @pulumi.getter(name="defaultPool") + def default_pool(self) -> pulumi.Input['ResourcePoolsConfigDefaultPoolArgs']: + return pulumi.get(self, "default_pool") + + @default_pool.setter + def default_pool(self, value: pulumi.Input['ResourcePoolsConfigDefaultPoolArgs']): + pulumi.set(self, "default_pool", value) + + @property + @pulumi.getter + def pool(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ResourcePoolsConfigPoolArgs']]]]: + return pulumi.get(self, "pool") + + @pool.setter + def pool(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ResourcePoolsConfigPoolArgs']]]]): + pulumi.set(self, "pool", value) + + @property + @pulumi.getter + def pools(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ResourcePoolsConfigPoolArgs']]]]: + warnings.warn("""Use pool instead of pools""", DeprecationWarning) + pulumi.log.warn("""pools is deprecated: Use pool instead of pools""") + + return pulumi.get(self, "pools") + + @pools.setter + def pools(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ResourcePoolsConfigPoolArgs']]]]): + pulumi.set(self, "pools", value) + + +@pulumi.input_type +class _ResourcePoolsConfigState: + def __init__(__self__, *, + default_pool: Optional[pulumi.Input['ResourcePoolsConfigDefaultPoolArgs']] = None, + pool: Optional[pulumi.Input[Sequence[pulumi.Input['ResourcePoolsConfigPoolArgs']]]] = None, + pools: Optional[pulumi.Input[Sequence[pulumi.Input['ResourcePoolsConfigPoolArgs']]]] = None): + """ + Input properties used for looking up and filtering ResourcePoolsConfig resources. + """ + if default_pool is not None: + pulumi.set(__self__, "default_pool", default_pool) + if pool is not None: + pulumi.set(__self__, "pool", pool) + if pools is not None: + warnings.warn("""Use pool instead of pools""", DeprecationWarning) + pulumi.log.warn("""pools is deprecated: Use pool instead of pools""") + if pools is not None: + pulumi.set(__self__, "pools", pools) + + @property + @pulumi.getter(name="defaultPool") + def default_pool(self) -> Optional[pulumi.Input['ResourcePoolsConfigDefaultPoolArgs']]: + return pulumi.get(self, "default_pool") + + @default_pool.setter + def default_pool(self, value: Optional[pulumi.Input['ResourcePoolsConfigDefaultPoolArgs']]): + pulumi.set(self, "default_pool", value) + + @property + @pulumi.getter + def pool(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ResourcePoolsConfigPoolArgs']]]]: + return pulumi.get(self, "pool") + + @pool.setter + def pool(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ResourcePoolsConfigPoolArgs']]]]): + pulumi.set(self, "pool", value) + + @property + @pulumi.getter + def pools(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ResourcePoolsConfigPoolArgs']]]]: + warnings.warn("""Use pool instead of pools""", DeprecationWarning) + pulumi.log.warn("""pools is deprecated: Use pool instead of pools""") + + return pulumi.get(self, "pools") + + @pools.setter + def pools(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ResourcePoolsConfigPoolArgs']]]]): + pulumi.set(self, "pools", value) + + +class ResourcePoolsConfig(pulumi.CustomResource): + @overload + def __init__(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + default_pool: Optional[pulumi.Input[pulumi.InputType['ResourcePoolsConfigDefaultPoolArgs']]] = None, + pool: Optional[pulumi.Input[Sequence[pulumi.Input[pulumi.InputType['ResourcePoolsConfigPoolArgs']]]]] = None, + pools: Optional[pulumi.Input[Sequence[pulumi.Input[pulumi.InputType['ResourcePoolsConfigPoolArgs']]]]] = None, + __props__=None): + """ + Create a ResourcePoolsConfig resource with the given unique name, props, and options. + :param str resource_name: The name of the resource. + :param pulumi.ResourceOptions opts: Options for the resource. + """ + ... + @overload + def __init__(__self__, + resource_name: str, + args: ResourcePoolsConfigArgs, + opts: Optional[pulumi.ResourceOptions] = None): + """ + Create a ResourcePoolsConfig resource with the given unique name, props, and options. + :param str resource_name: The name of the resource. + :param ResourcePoolsConfigArgs 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(ResourcePoolsConfigArgs, 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_pool: Optional[pulumi.Input[pulumi.InputType['ResourcePoolsConfigDefaultPoolArgs']]] = None, + pool: Optional[pulumi.Input[Sequence[pulumi.Input[pulumi.InputType['ResourcePoolsConfigPoolArgs']]]]] = None, + pools: Optional[pulumi.Input[Sequence[pulumi.Input[pulumi.InputType['ResourcePoolsConfigPoolArgs']]]]] = 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__ = ResourcePoolsConfigArgs.__new__(ResourcePoolsConfigArgs) + + if default_pool is None and not opts.urn: + raise TypeError("Missing required property 'default_pool'") + __props__.__dict__["default_pool"] = default_pool + __props__.__dict__["pool"] = pool + __props__.__dict__["pools"] = pools + super(ResourcePoolsConfig, __self__).__init__( + 'chronosphere:index/resourcePoolsConfig:ResourcePoolsConfig', + resource_name, + __props__, + opts) + + @staticmethod + def get(resource_name: str, + id: pulumi.Input[str], + opts: Optional[pulumi.ResourceOptions] = None, + default_pool: Optional[pulumi.Input[pulumi.InputType['ResourcePoolsConfigDefaultPoolArgs']]] = None, + pool: Optional[pulumi.Input[Sequence[pulumi.Input[pulumi.InputType['ResourcePoolsConfigPoolArgs']]]]] = None, + pools: Optional[pulumi.Input[Sequence[pulumi.Input[pulumi.InputType['ResourcePoolsConfigPoolArgs']]]]] = None) -> 'ResourcePoolsConfig': + """ + Get an existing ResourcePoolsConfig 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. + """ + opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id)) + + __props__ = _ResourcePoolsConfigState.__new__(_ResourcePoolsConfigState) + + __props__.__dict__["default_pool"] = default_pool + __props__.__dict__["pool"] = pool + __props__.__dict__["pools"] = pools + return ResourcePoolsConfig(resource_name, opts=opts, __props__=__props__) + + @property + @pulumi.getter(name="defaultPool") + def default_pool(self) -> pulumi.Output['outputs.ResourcePoolsConfigDefaultPool']: + return pulumi.get(self, "default_pool") + + @property + @pulumi.getter + def pool(self) -> pulumi.Output[Optional[Sequence['outputs.ResourcePoolsConfigPool']]]: + return pulumi.get(self, "pool") + + @property + @pulumi.getter + def pools(self) -> pulumi.Output[Optional[Sequence['outputs.ResourcePoolsConfigPool']]]: + warnings.warn("""Use pool instead of pools""", DeprecationWarning) + pulumi.log.warn("""pools is deprecated: Use pool instead of pools""") + + return pulumi.get(self, "pools") + diff --git a/sdk/python/chronosphereio_chronosphere/rollup_rule.py b/sdk/python/chronosphereio_chronosphere/rollup_rule.py new file mode 100644 index 00000000..b1873e8e --- /dev/null +++ b/sdk/python/chronosphereio_chronosphere/rollup_rule.py @@ -0,0 +1,612 @@ +# coding=utf-8 +# *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import copy +import warnings +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +from . import _utilities +from . import outputs +from ._inputs import * + +__all__ = ['RollupRuleArgs', 'RollupRule'] + +@pulumi.input_type +class RollupRuleArgs: + def __init__(__self__, *, + filter: pulumi.Input[str], + metric_type: pulumi.Input[str], + name: pulumi.Input[str], + slug: pulumi.Input[str], + aggregation: Optional[pulumi.Input[str]] = None, + bucket_id: Optional[pulumi.Input[str]] = None, + drop_raw: Optional[pulumi.Input[bool]] = None, + exclude_bies: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None, + group_bies: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None, + interval: Optional[pulumi.Input[str]] = None, + metric_type_tag: Optional[pulumi.Input[bool]] = None, + mode: Optional[pulumi.Input[str]] = None, + new_metric: Optional[pulumi.Input[str]] = None, + permissive: Optional[pulumi.Input[bool]] = None, + storage_policies: Optional[pulumi.Input['RollupRuleStoragePoliciesArgs']] = None): + """ + The set of arguments for constructing a RollupRule resource. + """ + pulumi.set(__self__, "filter", filter) + pulumi.set(__self__, "metric_type", metric_type) + pulumi.set(__self__, "name", name) + pulumi.set(__self__, "slug", slug) + if aggregation is not None: + pulumi.set(__self__, "aggregation", aggregation) + if bucket_id is not None: + pulumi.set(__self__, "bucket_id", bucket_id) + if drop_raw is not None: + pulumi.set(__self__, "drop_raw", drop_raw) + if exclude_bies is not None: + pulumi.set(__self__, "exclude_bies", exclude_bies) + if group_bies is not None: + pulumi.set(__self__, "group_bies", group_bies) + if interval is not None: + pulumi.set(__self__, "interval", interval) + if metric_type_tag is not None: + pulumi.set(__self__, "metric_type_tag", metric_type_tag) + if mode is not None: + pulumi.set(__self__, "mode", mode) + if new_metric is not None: + pulumi.set(__self__, "new_metric", new_metric) + if permissive is not None: + pulumi.set(__self__, "permissive", permissive) + if storage_policies is not None: + pulumi.set(__self__, "storage_policies", storage_policies) + + @property + @pulumi.getter + def filter(self) -> pulumi.Input[str]: + return pulumi.get(self, "filter") + + @filter.setter + def filter(self, value: pulumi.Input[str]): + pulumi.set(self, "filter", value) + + @property + @pulumi.getter(name="metricType") + def metric_type(self) -> pulumi.Input[str]: + return pulumi.get(self, "metric_type") + + @metric_type.setter + def metric_type(self, value: pulumi.Input[str]): + pulumi.set(self, "metric_type", value) + + @property + @pulumi.getter + def name(self) -> pulumi.Input[str]: + return pulumi.get(self, "name") + + @name.setter + def name(self, value: pulumi.Input[str]): + pulumi.set(self, "name", value) + + @property + @pulumi.getter + def slug(self) -> pulumi.Input[str]: + return pulumi.get(self, "slug") + + @slug.setter + def slug(self, value: pulumi.Input[str]): + pulumi.set(self, "slug", value) + + @property + @pulumi.getter + def aggregation(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "aggregation") + + @aggregation.setter + def aggregation(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "aggregation", value) + + @property + @pulumi.getter(name="bucketId") + def bucket_id(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "bucket_id") + + @bucket_id.setter + def bucket_id(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "bucket_id", value) + + @property + @pulumi.getter(name="dropRaw") + def drop_raw(self) -> Optional[pulumi.Input[bool]]: + return pulumi.get(self, "drop_raw") + + @drop_raw.setter + def drop_raw(self, value: Optional[pulumi.Input[bool]]): + pulumi.set(self, "drop_raw", value) + + @property + @pulumi.getter(name="excludeBies") + def exclude_bies(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]: + return pulumi.get(self, "exclude_bies") + + @exclude_bies.setter + def exclude_bies(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]): + pulumi.set(self, "exclude_bies", value) + + @property + @pulumi.getter(name="groupBies") + def group_bies(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]: + return pulumi.get(self, "group_bies") + + @group_bies.setter + def group_bies(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]): + pulumi.set(self, "group_bies", value) + + @property + @pulumi.getter + def interval(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "interval") + + @interval.setter + def interval(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "interval", value) + + @property + @pulumi.getter(name="metricTypeTag") + def metric_type_tag(self) -> Optional[pulumi.Input[bool]]: + return pulumi.get(self, "metric_type_tag") + + @metric_type_tag.setter + def metric_type_tag(self, value: Optional[pulumi.Input[bool]]): + pulumi.set(self, "metric_type_tag", value) + + @property + @pulumi.getter + def mode(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "mode") + + @mode.setter + def mode(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "mode", value) + + @property + @pulumi.getter(name="newMetric") + def new_metric(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "new_metric") + + @new_metric.setter + def new_metric(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "new_metric", value) + + @property + @pulumi.getter + def permissive(self) -> Optional[pulumi.Input[bool]]: + return pulumi.get(self, "permissive") + + @permissive.setter + def permissive(self, value: Optional[pulumi.Input[bool]]): + pulumi.set(self, "permissive", value) + + @property + @pulumi.getter(name="storagePolicies") + def storage_policies(self) -> Optional[pulumi.Input['RollupRuleStoragePoliciesArgs']]: + return pulumi.get(self, "storage_policies") + + @storage_policies.setter + def storage_policies(self, value: Optional[pulumi.Input['RollupRuleStoragePoliciesArgs']]): + pulumi.set(self, "storage_policies", value) + + +@pulumi.input_type +class _RollupRuleState: + def __init__(__self__, *, + aggregation: Optional[pulumi.Input[str]] = None, + bucket_id: Optional[pulumi.Input[str]] = None, + drop_raw: Optional[pulumi.Input[bool]] = None, + exclude_bies: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None, + filter: Optional[pulumi.Input[str]] = None, + group_bies: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None, + interval: Optional[pulumi.Input[str]] = None, + metric_type: Optional[pulumi.Input[str]] = None, + metric_type_tag: Optional[pulumi.Input[bool]] = None, + mode: Optional[pulumi.Input[str]] = None, + name: Optional[pulumi.Input[str]] = None, + new_metric: Optional[pulumi.Input[str]] = None, + permissive: Optional[pulumi.Input[bool]] = None, + slug: Optional[pulumi.Input[str]] = None, + storage_policies: Optional[pulumi.Input['RollupRuleStoragePoliciesArgs']] = None): + """ + Input properties used for looking up and filtering RollupRule resources. + """ + if aggregation is not None: + pulumi.set(__self__, "aggregation", aggregation) + if bucket_id is not None: + pulumi.set(__self__, "bucket_id", bucket_id) + if drop_raw is not None: + pulumi.set(__self__, "drop_raw", drop_raw) + if exclude_bies is not None: + pulumi.set(__self__, "exclude_bies", exclude_bies) + if filter is not None: + pulumi.set(__self__, "filter", filter) + if group_bies is not None: + pulumi.set(__self__, "group_bies", group_bies) + if interval is not None: + pulumi.set(__self__, "interval", interval) + if metric_type is not None: + pulumi.set(__self__, "metric_type", metric_type) + if metric_type_tag is not None: + pulumi.set(__self__, "metric_type_tag", metric_type_tag) + if mode is not None: + pulumi.set(__self__, "mode", mode) + if name is not None: + pulumi.set(__self__, "name", name) + if new_metric is not None: + pulumi.set(__self__, "new_metric", new_metric) + if permissive is not None: + pulumi.set(__self__, "permissive", permissive) + if slug is not None: + pulumi.set(__self__, "slug", slug) + if storage_policies is not None: + pulumi.set(__self__, "storage_policies", storage_policies) + + @property + @pulumi.getter + def aggregation(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "aggregation") + + @aggregation.setter + def aggregation(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "aggregation", value) + + @property + @pulumi.getter(name="bucketId") + def bucket_id(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "bucket_id") + + @bucket_id.setter + def bucket_id(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "bucket_id", value) + + @property + @pulumi.getter(name="dropRaw") + def drop_raw(self) -> Optional[pulumi.Input[bool]]: + return pulumi.get(self, "drop_raw") + + @drop_raw.setter + def drop_raw(self, value: Optional[pulumi.Input[bool]]): + pulumi.set(self, "drop_raw", value) + + @property + @pulumi.getter(name="excludeBies") + def exclude_bies(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]: + return pulumi.get(self, "exclude_bies") + + @exclude_bies.setter + def exclude_bies(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]): + pulumi.set(self, "exclude_bies", value) + + @property + @pulumi.getter + def filter(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "filter") + + @filter.setter + def filter(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "filter", value) + + @property + @pulumi.getter(name="groupBies") + def group_bies(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]: + return pulumi.get(self, "group_bies") + + @group_bies.setter + def group_bies(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]): + pulumi.set(self, "group_bies", value) + + @property + @pulumi.getter + def interval(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "interval") + + @interval.setter + def interval(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "interval", value) + + @property + @pulumi.getter(name="metricType") + def metric_type(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "metric_type") + + @metric_type.setter + def metric_type(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "metric_type", value) + + @property + @pulumi.getter(name="metricTypeTag") + def metric_type_tag(self) -> Optional[pulumi.Input[bool]]: + return pulumi.get(self, "metric_type_tag") + + @metric_type_tag.setter + def metric_type_tag(self, value: Optional[pulumi.Input[bool]]): + pulumi.set(self, "metric_type_tag", value) + + @property + @pulumi.getter + def mode(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "mode") + + @mode.setter + def mode(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "mode", value) + + @property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "name", value) + + @property + @pulumi.getter(name="newMetric") + def new_metric(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "new_metric") + + @new_metric.setter + def new_metric(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "new_metric", value) + + @property + @pulumi.getter + def permissive(self) -> Optional[pulumi.Input[bool]]: + return pulumi.get(self, "permissive") + + @permissive.setter + def permissive(self, value: Optional[pulumi.Input[bool]]): + pulumi.set(self, "permissive", value) + + @property + @pulumi.getter + def slug(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "slug") + + @slug.setter + def slug(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "slug", value) + + @property + @pulumi.getter(name="storagePolicies") + def storage_policies(self) -> Optional[pulumi.Input['RollupRuleStoragePoliciesArgs']]: + return pulumi.get(self, "storage_policies") + + @storage_policies.setter + def storage_policies(self, value: Optional[pulumi.Input['RollupRuleStoragePoliciesArgs']]): + pulumi.set(self, "storage_policies", value) + + +class RollupRule(pulumi.CustomResource): + @overload + def __init__(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + aggregation: Optional[pulumi.Input[str]] = None, + bucket_id: Optional[pulumi.Input[str]] = None, + drop_raw: Optional[pulumi.Input[bool]] = None, + exclude_bies: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None, + filter: Optional[pulumi.Input[str]] = None, + group_bies: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None, + interval: Optional[pulumi.Input[str]] = None, + metric_type: Optional[pulumi.Input[str]] = None, + metric_type_tag: Optional[pulumi.Input[bool]] = None, + mode: Optional[pulumi.Input[str]] = None, + name: Optional[pulumi.Input[str]] = None, + new_metric: Optional[pulumi.Input[str]] = None, + permissive: Optional[pulumi.Input[bool]] = None, + slug: Optional[pulumi.Input[str]] = None, + storage_policies: Optional[pulumi.Input[pulumi.InputType['RollupRuleStoragePoliciesArgs']]] = None, + __props__=None): + """ + Create a RollupRule resource with the given unique name, props, and options. + :param str resource_name: The name of the resource. + :param pulumi.ResourceOptions opts: Options for the resource. + """ + ... + @overload + def __init__(__self__, + resource_name: str, + args: RollupRuleArgs, + opts: Optional[pulumi.ResourceOptions] = None): + """ + Create a RollupRule resource with the given unique name, props, and options. + :param str resource_name: The name of the resource. + :param RollupRuleArgs 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(RollupRuleArgs, 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, + aggregation: Optional[pulumi.Input[str]] = None, + bucket_id: Optional[pulumi.Input[str]] = None, + drop_raw: Optional[pulumi.Input[bool]] = None, + exclude_bies: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None, + filter: Optional[pulumi.Input[str]] = None, + group_bies: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None, + interval: Optional[pulumi.Input[str]] = None, + metric_type: Optional[pulumi.Input[str]] = None, + metric_type_tag: Optional[pulumi.Input[bool]] = None, + mode: Optional[pulumi.Input[str]] = None, + name: Optional[pulumi.Input[str]] = None, + new_metric: Optional[pulumi.Input[str]] = None, + permissive: Optional[pulumi.Input[bool]] = None, + slug: Optional[pulumi.Input[str]] = None, + storage_policies: Optional[pulumi.Input[pulumi.InputType['RollupRuleStoragePoliciesArgs']]] = 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__ = RollupRuleArgs.__new__(RollupRuleArgs) + + __props__.__dict__["aggregation"] = aggregation + __props__.__dict__["bucket_id"] = bucket_id + __props__.__dict__["drop_raw"] = drop_raw + __props__.__dict__["exclude_bies"] = exclude_bies + if filter is None and not opts.urn: + raise TypeError("Missing required property 'filter'") + __props__.__dict__["filter"] = filter + __props__.__dict__["group_bies"] = group_bies + __props__.__dict__["interval"] = interval + if metric_type is None and not opts.urn: + raise TypeError("Missing required property 'metric_type'") + __props__.__dict__["metric_type"] = metric_type + __props__.__dict__["metric_type_tag"] = metric_type_tag + __props__.__dict__["mode"] = mode + if name is None and not opts.urn: + raise TypeError("Missing required property 'name'") + __props__.__dict__["name"] = name + __props__.__dict__["new_metric"] = new_metric + __props__.__dict__["permissive"] = permissive + if slug is None and not opts.urn: + raise TypeError("Missing required property 'slug'") + __props__.__dict__["slug"] = slug + __props__.__dict__["storage_policies"] = storage_policies + super(RollupRule, __self__).__init__( + 'chronosphere:index/rollupRule:RollupRule', + resource_name, + __props__, + opts) + + @staticmethod + def get(resource_name: str, + id: pulumi.Input[str], + opts: Optional[pulumi.ResourceOptions] = None, + aggregation: Optional[pulumi.Input[str]] = None, + bucket_id: Optional[pulumi.Input[str]] = None, + drop_raw: Optional[pulumi.Input[bool]] = None, + exclude_bies: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None, + filter: Optional[pulumi.Input[str]] = None, + group_bies: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None, + interval: Optional[pulumi.Input[str]] = None, + metric_type: Optional[pulumi.Input[str]] = None, + metric_type_tag: Optional[pulumi.Input[bool]] = None, + mode: Optional[pulumi.Input[str]] = None, + name: Optional[pulumi.Input[str]] = None, + new_metric: Optional[pulumi.Input[str]] = None, + permissive: Optional[pulumi.Input[bool]] = None, + slug: Optional[pulumi.Input[str]] = None, + storage_policies: Optional[pulumi.Input[pulumi.InputType['RollupRuleStoragePoliciesArgs']]] = None) -> 'RollupRule': + """ + Get an existing RollupRule 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. + """ + opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id)) + + __props__ = _RollupRuleState.__new__(_RollupRuleState) + + __props__.__dict__["aggregation"] = aggregation + __props__.__dict__["bucket_id"] = bucket_id + __props__.__dict__["drop_raw"] = drop_raw + __props__.__dict__["exclude_bies"] = exclude_bies + __props__.__dict__["filter"] = filter + __props__.__dict__["group_bies"] = group_bies + __props__.__dict__["interval"] = interval + __props__.__dict__["metric_type"] = metric_type + __props__.__dict__["metric_type_tag"] = metric_type_tag + __props__.__dict__["mode"] = mode + __props__.__dict__["name"] = name + __props__.__dict__["new_metric"] = new_metric + __props__.__dict__["permissive"] = permissive + __props__.__dict__["slug"] = slug + __props__.__dict__["storage_policies"] = storage_policies + return RollupRule(resource_name, opts=opts, __props__=__props__) + + @property + @pulumi.getter + def aggregation(self) -> pulumi.Output[Optional[str]]: + return pulumi.get(self, "aggregation") + + @property + @pulumi.getter(name="bucketId") + def bucket_id(self) -> pulumi.Output[Optional[str]]: + return pulumi.get(self, "bucket_id") + + @property + @pulumi.getter(name="dropRaw") + def drop_raw(self) -> pulumi.Output[Optional[bool]]: + return pulumi.get(self, "drop_raw") + + @property + @pulumi.getter(name="excludeBies") + def exclude_bies(self) -> pulumi.Output[Optional[Sequence[str]]]: + return pulumi.get(self, "exclude_bies") + + @property + @pulumi.getter + def filter(self) -> pulumi.Output[str]: + return pulumi.get(self, "filter") + + @property + @pulumi.getter(name="groupBies") + def group_bies(self) -> pulumi.Output[Optional[Sequence[str]]]: + return pulumi.get(self, "group_bies") + + @property + @pulumi.getter + def interval(self) -> pulumi.Output[Optional[str]]: + return pulumi.get(self, "interval") + + @property + @pulumi.getter(name="metricType") + def metric_type(self) -> pulumi.Output[str]: + return pulumi.get(self, "metric_type") + + @property + @pulumi.getter(name="metricTypeTag") + def metric_type_tag(self) -> pulumi.Output[Optional[bool]]: + return pulumi.get(self, "metric_type_tag") + + @property + @pulumi.getter + def mode(self) -> pulumi.Output[Optional[str]]: + return pulumi.get(self, "mode") + + @property + @pulumi.getter + def name(self) -> pulumi.Output[str]: + return pulumi.get(self, "name") + + @property + @pulumi.getter(name="newMetric") + def new_metric(self) -> pulumi.Output[Optional[str]]: + return pulumi.get(self, "new_metric") + + @property + @pulumi.getter + def permissive(self) -> pulumi.Output[Optional[bool]]: + return pulumi.get(self, "permissive") + + @property + @pulumi.getter + def slug(self) -> pulumi.Output[str]: + return pulumi.get(self, "slug") + + @property + @pulumi.getter(name="storagePolicies") + def storage_policies(self) -> pulumi.Output['outputs.RollupRuleStoragePolicies']: + return pulumi.get(self, "storage_policies") + diff --git a/sdk/python/chronosphereio_chronosphere/service_account.py b/sdk/python/chronosphereio_chronosphere/service_account.py new file mode 100644 index 00000000..a589c122 --- /dev/null +++ b/sdk/python/chronosphereio_chronosphere/service_account.py @@ -0,0 +1,277 @@ +# coding=utf-8 +# *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import copy +import warnings +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +from . import _utilities +from . import outputs +from ._inputs import * + +__all__ = ['ServiceAccountArgs', 'ServiceAccount'] + +@pulumi.input_type +class ServiceAccountArgs: + def __init__(__self__, *, + name: pulumi.Input[str], + restriction: Optional[pulumi.Input['ServiceAccountRestrictionArgs']] = None, + slug: Optional[pulumi.Input[str]] = None, + unrestricted: Optional[pulumi.Input[bool]] = None): + """ + The set of arguments for constructing a ServiceAccount resource. + """ + pulumi.set(__self__, "name", name) + if restriction is not None: + pulumi.set(__self__, "restriction", restriction) + if slug is not None: + pulumi.set(__self__, "slug", slug) + if unrestricted is not None: + pulumi.set(__self__, "unrestricted", unrestricted) + + @property + @pulumi.getter + def name(self) -> pulumi.Input[str]: + return pulumi.get(self, "name") + + @name.setter + def name(self, value: pulumi.Input[str]): + pulumi.set(self, "name", value) + + @property + @pulumi.getter + def restriction(self) -> Optional[pulumi.Input['ServiceAccountRestrictionArgs']]: + return pulumi.get(self, "restriction") + + @restriction.setter + def restriction(self, value: Optional[pulumi.Input['ServiceAccountRestrictionArgs']]): + pulumi.set(self, "restriction", value) + + @property + @pulumi.getter + def slug(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "slug") + + @slug.setter + def slug(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "slug", value) + + @property + @pulumi.getter + def unrestricted(self) -> Optional[pulumi.Input[bool]]: + return pulumi.get(self, "unrestricted") + + @unrestricted.setter + def unrestricted(self, value: Optional[pulumi.Input[bool]]): + pulumi.set(self, "unrestricted", value) + + +@pulumi.input_type +class _ServiceAccountState: + def __init__(__self__, *, + email: Optional[pulumi.Input[str]] = None, + name: Optional[pulumi.Input[str]] = None, + restriction: Optional[pulumi.Input['ServiceAccountRestrictionArgs']] = None, + slug: Optional[pulumi.Input[str]] = None, + token: Optional[pulumi.Input[str]] = None, + unrestricted: Optional[pulumi.Input[bool]] = None): + """ + Input properties used for looking up and filtering ServiceAccount resources. + """ + if email is not None: + pulumi.set(__self__, "email", email) + if name is not None: + pulumi.set(__self__, "name", name) + if restriction is not None: + pulumi.set(__self__, "restriction", restriction) + if slug is not None: + pulumi.set(__self__, "slug", slug) + if token is not None: + pulumi.set(__self__, "token", token) + if unrestricted is not None: + pulumi.set(__self__, "unrestricted", unrestricted) + + @property + @pulumi.getter + def email(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "email") + + @email.setter + def email(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "email", value) + + @property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "name", value) + + @property + @pulumi.getter + def restriction(self) -> Optional[pulumi.Input['ServiceAccountRestrictionArgs']]: + return pulumi.get(self, "restriction") + + @restriction.setter + def restriction(self, value: Optional[pulumi.Input['ServiceAccountRestrictionArgs']]): + pulumi.set(self, "restriction", value) + + @property + @pulumi.getter + def slug(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "slug") + + @slug.setter + def slug(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "slug", value) + + @property + @pulumi.getter + def token(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "token") + + @token.setter + def token(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "token", value) + + @property + @pulumi.getter + def unrestricted(self) -> Optional[pulumi.Input[bool]]: + return pulumi.get(self, "unrestricted") + + @unrestricted.setter + def unrestricted(self, value: Optional[pulumi.Input[bool]]): + pulumi.set(self, "unrestricted", value) + + +class ServiceAccount(pulumi.CustomResource): + @overload + def __init__(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + name: Optional[pulumi.Input[str]] = None, + restriction: Optional[pulumi.Input[pulumi.InputType['ServiceAccountRestrictionArgs']]] = None, + slug: Optional[pulumi.Input[str]] = None, + unrestricted: Optional[pulumi.Input[bool]] = None, + __props__=None): + """ + Create a ServiceAccount resource with the given unique name, props, and options. + :param str resource_name: The name of the resource. + :param pulumi.ResourceOptions opts: Options for the resource. + """ + ... + @overload + def __init__(__self__, + resource_name: str, + args: ServiceAccountArgs, + opts: Optional[pulumi.ResourceOptions] = None): + """ + Create a ServiceAccount resource with the given unique name, props, and options. + :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[str]] = None, + restriction: Optional[pulumi.Input[pulumi.InputType['ServiceAccountRestrictionArgs']]] = None, + slug: Optional[pulumi.Input[str]] = None, + unrestricted: Optional[pulumi.Input[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__ = ServiceAccountArgs.__new__(ServiceAccountArgs) + + if name is None and not opts.urn: + raise TypeError("Missing required property 'name'") + __props__.__dict__["name"] = name + __props__.__dict__["restriction"] = restriction + __props__.__dict__["slug"] = slug + __props__.__dict__["unrestricted"] = unrestricted + __props__.__dict__["email"] = None + __props__.__dict__["token"] = None + secret_opts = pulumi.ResourceOptions(additional_secret_outputs=["token"]) + opts = pulumi.ResourceOptions.merge(opts, secret_opts) + super(ServiceAccount, __self__).__init__( + 'chronosphere: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[str]] = None, + name: Optional[pulumi.Input[str]] = None, + restriction: Optional[pulumi.Input[pulumi.InputType['ServiceAccountRestrictionArgs']]] = None, + slug: Optional[pulumi.Input[str]] = None, + token: Optional[pulumi.Input[str]] = None, + unrestricted: Optional[pulumi.Input[bool]] = 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. + """ + opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id)) + + __props__ = _ServiceAccountState.__new__(_ServiceAccountState) + + __props__.__dict__["email"] = email + __props__.__dict__["name"] = name + __props__.__dict__["restriction"] = restriction + __props__.__dict__["slug"] = slug + __props__.__dict__["token"] = token + __props__.__dict__["unrestricted"] = unrestricted + return ServiceAccount(resource_name, opts=opts, __props__=__props__) + + @property + @pulumi.getter + def email(self) -> pulumi.Output[str]: + return pulumi.get(self, "email") + + @property + @pulumi.getter + def name(self) -> pulumi.Output[str]: + return pulumi.get(self, "name") + + @property + @pulumi.getter + def restriction(self) -> pulumi.Output[Optional['outputs.ServiceAccountRestriction']]: + return pulumi.get(self, "restriction") + + @property + @pulumi.getter + def slug(self) -> pulumi.Output[str]: + return pulumi.get(self, "slug") + + @property + @pulumi.getter + def token(self) -> pulumi.Output[str]: + return pulumi.get(self, "token") + + @property + @pulumi.getter + def unrestricted(self) -> pulumi.Output[Optional[bool]]: + return pulumi.get(self, "unrestricted") + diff --git a/sdk/python/chronosphereio_chronosphere/service_data_source.py b/sdk/python/chronosphereio_chronosphere/service_data_source.py new file mode 100644 index 00000000..9d9cfea1 --- /dev/null +++ b/sdk/python/chronosphereio_chronosphere/service_data_source.py @@ -0,0 +1,97 @@ +# coding=utf-8 +# *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import copy +import warnings +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +from . import _utilities + +__all__ = [ + 'ServiceDataSourceResult', + 'AwaitableServiceDataSourceResult', + 'service_data_source', + 'service_data_source_output', +] + +@pulumi.output_type +class ServiceDataSourceResult: + """ + A collection of values returned by ServiceDataSource. + """ + def __init__(__self__, description=None, id=None, name=None, slug=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 name and not isinstance(name, str): + raise TypeError("Expected argument 'name' to be a str") + pulumi.set(__self__, "name", name) + if slug and not isinstance(slug, str): + raise TypeError("Expected argument 'slug' to be a str") + pulumi.set(__self__, "slug", slug) + + @property + @pulumi.getter + def description(self) -> str: + return pulumi.get(self, "description") + + @property + @pulumi.getter + def id(self) -> str: + """ + The provider-assigned unique ID for this managed resource. + """ + return pulumi.get(self, "id") + + @property + @pulumi.getter + def name(self) -> str: + return pulumi.get(self, "name") + + @property + @pulumi.getter + def slug(self) -> str: + return pulumi.get(self, "slug") + + +class AwaitableServiceDataSourceResult(ServiceDataSourceResult): + # pylint: disable=using-constant-test + def __await__(self): + if False: + yield self + return ServiceDataSourceResult( + description=self.description, + id=self.id, + name=self.name, + slug=self.slug) + + +def service_data_source(slug: Optional[str] = None, + opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableServiceDataSourceResult: + """ + Use this data source to access information about an existing resource. + """ + __args__ = dict() + __args__['slug'] = slug + opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke('chronosphere:index/serviceDataSource:ServiceDataSource', __args__, opts=opts, typ=ServiceDataSourceResult).value + + return AwaitableServiceDataSourceResult( + description=pulumi.get(__ret__, 'description'), + id=pulumi.get(__ret__, 'id'), + name=pulumi.get(__ret__, 'name'), + slug=pulumi.get(__ret__, 'slug')) + + +@_utilities.lift_output_func(service_data_source) +def service_data_source_output(slug: Optional[pulumi.Input[str]] = None, + opts: Optional[pulumi.InvokeOptions] = None) -> pulumi.Output[ServiceDataSourceResult]: + """ + Use this data source to access information about an existing resource. + """ + ... diff --git a/sdk/python/chronosphereio_chronosphere/slack_alert_notifier.py b/sdk/python/chronosphereio_chronosphere/slack_alert_notifier.py new file mode 100644 index 00000000..28d95e18 --- /dev/null +++ b/sdk/python/chronosphereio_chronosphere/slack_alert_notifier.py @@ -0,0 +1,1055 @@ +# coding=utf-8 +# *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import copy +import warnings +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +from . import _utilities +from . import outputs +from ._inputs import * + +__all__ = ['SlackAlertNotifierArgs', 'SlackAlertNotifier'] + +@pulumi.input_type +class SlackAlertNotifierArgs: + def __init__(__self__, *, + api_url: pulumi.Input[str], + channel: pulumi.Input[str], + name: pulumi.Input[str], + actions: Optional[pulumi.Input[Sequence[pulumi.Input['SlackAlertNotifierActionArgs']]]] = None, + basic_auth_password: Optional[pulumi.Input[str]] = None, + basic_auth_username: Optional[pulumi.Input[str]] = None, + bearer_token: Optional[pulumi.Input[str]] = None, + callback_id: Optional[pulumi.Input[str]] = None, + color: Optional[pulumi.Input[str]] = None, + fallback: Optional[pulumi.Input[str]] = None, + fields: Optional[pulumi.Input[Sequence[pulumi.Input['SlackAlertNotifierFieldArgs']]]] = None, + footer: Optional[pulumi.Input[str]] = None, + icon_emoji: Optional[pulumi.Input[str]] = None, + icon_url: Optional[pulumi.Input[str]] = None, + image_url: Optional[pulumi.Input[str]] = None, + link_names: Optional[pulumi.Input[bool]] = None, + mrkdwn_ins: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None, + pretext: Optional[pulumi.Input[str]] = None, + proxy_url: Optional[pulumi.Input[str]] = None, + send_resolved: Optional[pulumi.Input[bool]] = None, + short_fields: Optional[pulumi.Input[bool]] = None, + slug: Optional[pulumi.Input[str]] = None, + text: Optional[pulumi.Input[str]] = None, + thumb_url: Optional[pulumi.Input[str]] = None, + title: Optional[pulumi.Input[str]] = None, + title_link: Optional[pulumi.Input[str]] = None, + tls_insecure_skip_verify: Optional[pulumi.Input[bool]] = None, + username: Optional[pulumi.Input[str]] = None): + """ + The set of arguments for constructing a SlackAlertNotifier resource. + """ + pulumi.set(__self__, "api_url", api_url) + pulumi.set(__self__, "channel", channel) + pulumi.set(__self__, "name", name) + if actions is not None: + pulumi.set(__self__, "actions", actions) + if basic_auth_password is not None: + pulumi.set(__self__, "basic_auth_password", basic_auth_password) + if basic_auth_username is not None: + pulumi.set(__self__, "basic_auth_username", basic_auth_username) + if bearer_token is not None: + pulumi.set(__self__, "bearer_token", bearer_token) + if callback_id is not None: + pulumi.set(__self__, "callback_id", callback_id) + if color is not None: + pulumi.set(__self__, "color", color) + if fallback is not None: + pulumi.set(__self__, "fallback", fallback) + if fields is not None: + pulumi.set(__self__, "fields", fields) + if footer is not None: + pulumi.set(__self__, "footer", footer) + if icon_emoji is not None: + pulumi.set(__self__, "icon_emoji", icon_emoji) + if icon_url is not None: + pulumi.set(__self__, "icon_url", icon_url) + if image_url is not None: + pulumi.set(__self__, "image_url", image_url) + if link_names is not None: + pulumi.set(__self__, "link_names", link_names) + if mrkdwn_ins is not None: + pulumi.set(__self__, "mrkdwn_ins", mrkdwn_ins) + if pretext is not None: + pulumi.set(__self__, "pretext", pretext) + if proxy_url is not None: + pulumi.set(__self__, "proxy_url", proxy_url) + if send_resolved is not None: + pulumi.set(__self__, "send_resolved", send_resolved) + if short_fields is not None: + pulumi.set(__self__, "short_fields", short_fields) + if slug is not None: + pulumi.set(__self__, "slug", slug) + if text is not None: + pulumi.set(__self__, "text", text) + if thumb_url is not None: + pulumi.set(__self__, "thumb_url", thumb_url) + if title is not None: + pulumi.set(__self__, "title", title) + if title_link is not None: + pulumi.set(__self__, "title_link", title_link) + if tls_insecure_skip_verify is not None: + pulumi.set(__self__, "tls_insecure_skip_verify", tls_insecure_skip_verify) + if username is not None: + pulumi.set(__self__, "username", username) + + @property + @pulumi.getter(name="apiUrl") + def api_url(self) -> pulumi.Input[str]: + return pulumi.get(self, "api_url") + + @api_url.setter + def api_url(self, value: pulumi.Input[str]): + pulumi.set(self, "api_url", value) + + @property + @pulumi.getter + def channel(self) -> pulumi.Input[str]: + return pulumi.get(self, "channel") + + @channel.setter + def channel(self, value: pulumi.Input[str]): + pulumi.set(self, "channel", value) + + @property + @pulumi.getter + def name(self) -> pulumi.Input[str]: + return pulumi.get(self, "name") + + @name.setter + def name(self, value: pulumi.Input[str]): + pulumi.set(self, "name", value) + + @property + @pulumi.getter + def actions(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['SlackAlertNotifierActionArgs']]]]: + return pulumi.get(self, "actions") + + @actions.setter + def actions(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['SlackAlertNotifierActionArgs']]]]): + pulumi.set(self, "actions", value) + + @property + @pulumi.getter(name="basicAuthPassword") + def basic_auth_password(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "basic_auth_password") + + @basic_auth_password.setter + def basic_auth_password(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "basic_auth_password", value) + + @property + @pulumi.getter(name="basicAuthUsername") + def basic_auth_username(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "basic_auth_username") + + @basic_auth_username.setter + def basic_auth_username(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "basic_auth_username", value) + + @property + @pulumi.getter(name="bearerToken") + def bearer_token(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "bearer_token") + + @bearer_token.setter + def bearer_token(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "bearer_token", value) + + @property + @pulumi.getter(name="callbackId") + def callback_id(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "callback_id") + + @callback_id.setter + def callback_id(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "callback_id", value) + + @property + @pulumi.getter + def color(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "color") + + @color.setter + def color(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "color", value) + + @property + @pulumi.getter + def fallback(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "fallback") + + @fallback.setter + def fallback(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "fallback", value) + + @property + @pulumi.getter + def fields(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['SlackAlertNotifierFieldArgs']]]]: + return pulumi.get(self, "fields") + + @fields.setter + def fields(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['SlackAlertNotifierFieldArgs']]]]): + pulumi.set(self, "fields", value) + + @property + @pulumi.getter + def footer(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "footer") + + @footer.setter + def footer(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "footer", value) + + @property + @pulumi.getter(name="iconEmoji") + def icon_emoji(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "icon_emoji") + + @icon_emoji.setter + def icon_emoji(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "icon_emoji", value) + + @property + @pulumi.getter(name="iconUrl") + def icon_url(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "icon_url") + + @icon_url.setter + def icon_url(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "icon_url", value) + + @property + @pulumi.getter(name="imageUrl") + def image_url(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "image_url") + + @image_url.setter + def image_url(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "image_url", value) + + @property + @pulumi.getter(name="linkNames") + def link_names(self) -> Optional[pulumi.Input[bool]]: + return pulumi.get(self, "link_names") + + @link_names.setter + def link_names(self, value: Optional[pulumi.Input[bool]]): + pulumi.set(self, "link_names", value) + + @property + @pulumi.getter(name="mrkdwnIns") + def mrkdwn_ins(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]: + return pulumi.get(self, "mrkdwn_ins") + + @mrkdwn_ins.setter + def mrkdwn_ins(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]): + pulumi.set(self, "mrkdwn_ins", value) + + @property + @pulumi.getter + def pretext(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "pretext") + + @pretext.setter + def pretext(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "pretext", value) + + @property + @pulumi.getter(name="proxyUrl") + def proxy_url(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "proxy_url") + + @proxy_url.setter + def proxy_url(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "proxy_url", value) + + @property + @pulumi.getter(name="sendResolved") + def send_resolved(self) -> Optional[pulumi.Input[bool]]: + return pulumi.get(self, "send_resolved") + + @send_resolved.setter + def send_resolved(self, value: Optional[pulumi.Input[bool]]): + pulumi.set(self, "send_resolved", value) + + @property + @pulumi.getter(name="shortFields") + def short_fields(self) -> Optional[pulumi.Input[bool]]: + return pulumi.get(self, "short_fields") + + @short_fields.setter + def short_fields(self, value: Optional[pulumi.Input[bool]]): + pulumi.set(self, "short_fields", value) + + @property + @pulumi.getter + def slug(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "slug") + + @slug.setter + def slug(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "slug", value) + + @property + @pulumi.getter + def text(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "text") + + @text.setter + def text(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "text", value) + + @property + @pulumi.getter(name="thumbUrl") + def thumb_url(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "thumb_url") + + @thumb_url.setter + def thumb_url(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "thumb_url", value) + + @property + @pulumi.getter + def title(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "title") + + @title.setter + def title(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "title", value) + + @property + @pulumi.getter(name="titleLink") + def title_link(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "title_link") + + @title_link.setter + def title_link(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "title_link", value) + + @property + @pulumi.getter(name="tlsInsecureSkipVerify") + def tls_insecure_skip_verify(self) -> Optional[pulumi.Input[bool]]: + return pulumi.get(self, "tls_insecure_skip_verify") + + @tls_insecure_skip_verify.setter + def tls_insecure_skip_verify(self, value: Optional[pulumi.Input[bool]]): + pulumi.set(self, "tls_insecure_skip_verify", value) + + @property + @pulumi.getter + def username(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "username") + + @username.setter + def username(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "username", value) + + +@pulumi.input_type +class _SlackAlertNotifierState: + def __init__(__self__, *, + actions: Optional[pulumi.Input[Sequence[pulumi.Input['SlackAlertNotifierActionArgs']]]] = None, + api_url: Optional[pulumi.Input[str]] = None, + basic_auth_password: Optional[pulumi.Input[str]] = None, + basic_auth_username: Optional[pulumi.Input[str]] = None, + bearer_token: Optional[pulumi.Input[str]] = None, + callback_id: Optional[pulumi.Input[str]] = None, + channel: Optional[pulumi.Input[str]] = None, + color: Optional[pulumi.Input[str]] = None, + fallback: Optional[pulumi.Input[str]] = None, + fields: Optional[pulumi.Input[Sequence[pulumi.Input['SlackAlertNotifierFieldArgs']]]] = None, + footer: Optional[pulumi.Input[str]] = None, + icon_emoji: Optional[pulumi.Input[str]] = None, + icon_url: Optional[pulumi.Input[str]] = None, + image_url: Optional[pulumi.Input[str]] = None, + link_names: Optional[pulumi.Input[bool]] = None, + mrkdwn_ins: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None, + name: Optional[pulumi.Input[str]] = None, + pretext: Optional[pulumi.Input[str]] = None, + proxy_url: Optional[pulumi.Input[str]] = None, + send_resolved: Optional[pulumi.Input[bool]] = None, + short_fields: Optional[pulumi.Input[bool]] = None, + slug: Optional[pulumi.Input[str]] = None, + text: Optional[pulumi.Input[str]] = None, + thumb_url: Optional[pulumi.Input[str]] = None, + title: Optional[pulumi.Input[str]] = None, + title_link: Optional[pulumi.Input[str]] = None, + tls_insecure_skip_verify: Optional[pulumi.Input[bool]] = None, + username: Optional[pulumi.Input[str]] = None): + """ + Input properties used for looking up and filtering SlackAlertNotifier resources. + """ + if actions is not None: + pulumi.set(__self__, "actions", actions) + if api_url is not None: + pulumi.set(__self__, "api_url", api_url) + if basic_auth_password is not None: + pulumi.set(__self__, "basic_auth_password", basic_auth_password) + if basic_auth_username is not None: + pulumi.set(__self__, "basic_auth_username", basic_auth_username) + if bearer_token is not None: + pulumi.set(__self__, "bearer_token", bearer_token) + if callback_id is not None: + pulumi.set(__self__, "callback_id", callback_id) + if channel is not None: + pulumi.set(__self__, "channel", channel) + if color is not None: + pulumi.set(__self__, "color", color) + if fallback is not None: + pulumi.set(__self__, "fallback", fallback) + if fields is not None: + pulumi.set(__self__, "fields", fields) + if footer is not None: + pulumi.set(__self__, "footer", footer) + if icon_emoji is not None: + pulumi.set(__self__, "icon_emoji", icon_emoji) + if icon_url is not None: + pulumi.set(__self__, "icon_url", icon_url) + if image_url is not None: + pulumi.set(__self__, "image_url", image_url) + if link_names is not None: + pulumi.set(__self__, "link_names", link_names) + if mrkdwn_ins is not None: + pulumi.set(__self__, "mrkdwn_ins", mrkdwn_ins) + if name is not None: + pulumi.set(__self__, "name", name) + if pretext is not None: + pulumi.set(__self__, "pretext", pretext) + if proxy_url is not None: + pulumi.set(__self__, "proxy_url", proxy_url) + if send_resolved is not None: + pulumi.set(__self__, "send_resolved", send_resolved) + if short_fields is not None: + pulumi.set(__self__, "short_fields", short_fields) + if slug is not None: + pulumi.set(__self__, "slug", slug) + if text is not None: + pulumi.set(__self__, "text", text) + if thumb_url is not None: + pulumi.set(__self__, "thumb_url", thumb_url) + if title is not None: + pulumi.set(__self__, "title", title) + if title_link is not None: + pulumi.set(__self__, "title_link", title_link) + if tls_insecure_skip_verify is not None: + pulumi.set(__self__, "tls_insecure_skip_verify", tls_insecure_skip_verify) + if username is not None: + pulumi.set(__self__, "username", username) + + @property + @pulumi.getter + def actions(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['SlackAlertNotifierActionArgs']]]]: + return pulumi.get(self, "actions") + + @actions.setter + def actions(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['SlackAlertNotifierActionArgs']]]]): + pulumi.set(self, "actions", value) + + @property + @pulumi.getter(name="apiUrl") + def api_url(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "api_url") + + @api_url.setter + def api_url(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "api_url", value) + + @property + @pulumi.getter(name="basicAuthPassword") + def basic_auth_password(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "basic_auth_password") + + @basic_auth_password.setter + def basic_auth_password(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "basic_auth_password", value) + + @property + @pulumi.getter(name="basicAuthUsername") + def basic_auth_username(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "basic_auth_username") + + @basic_auth_username.setter + def basic_auth_username(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "basic_auth_username", value) + + @property + @pulumi.getter(name="bearerToken") + def bearer_token(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "bearer_token") + + @bearer_token.setter + def bearer_token(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "bearer_token", value) + + @property + @pulumi.getter(name="callbackId") + def callback_id(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "callback_id") + + @callback_id.setter + def callback_id(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "callback_id", value) + + @property + @pulumi.getter + def channel(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "channel") + + @channel.setter + def channel(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "channel", value) + + @property + @pulumi.getter + def color(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "color") + + @color.setter + def color(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "color", value) + + @property + @pulumi.getter + def fallback(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "fallback") + + @fallback.setter + def fallback(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "fallback", value) + + @property + @pulumi.getter + def fields(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['SlackAlertNotifierFieldArgs']]]]: + return pulumi.get(self, "fields") + + @fields.setter + def fields(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['SlackAlertNotifierFieldArgs']]]]): + pulumi.set(self, "fields", value) + + @property + @pulumi.getter + def footer(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "footer") + + @footer.setter + def footer(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "footer", value) + + @property + @pulumi.getter(name="iconEmoji") + def icon_emoji(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "icon_emoji") + + @icon_emoji.setter + def icon_emoji(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "icon_emoji", value) + + @property + @pulumi.getter(name="iconUrl") + def icon_url(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "icon_url") + + @icon_url.setter + def icon_url(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "icon_url", value) + + @property + @pulumi.getter(name="imageUrl") + def image_url(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "image_url") + + @image_url.setter + def image_url(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "image_url", value) + + @property + @pulumi.getter(name="linkNames") + def link_names(self) -> Optional[pulumi.Input[bool]]: + return pulumi.get(self, "link_names") + + @link_names.setter + def link_names(self, value: Optional[pulumi.Input[bool]]): + pulumi.set(self, "link_names", value) + + @property + @pulumi.getter(name="mrkdwnIns") + def mrkdwn_ins(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]: + return pulumi.get(self, "mrkdwn_ins") + + @mrkdwn_ins.setter + def mrkdwn_ins(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]): + pulumi.set(self, "mrkdwn_ins", value) + + @property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "name", value) + + @property + @pulumi.getter + def pretext(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "pretext") + + @pretext.setter + def pretext(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "pretext", value) + + @property + @pulumi.getter(name="proxyUrl") + def proxy_url(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "proxy_url") + + @proxy_url.setter + def proxy_url(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "proxy_url", value) + + @property + @pulumi.getter(name="sendResolved") + def send_resolved(self) -> Optional[pulumi.Input[bool]]: + return pulumi.get(self, "send_resolved") + + @send_resolved.setter + def send_resolved(self, value: Optional[pulumi.Input[bool]]): + pulumi.set(self, "send_resolved", value) + + @property + @pulumi.getter(name="shortFields") + def short_fields(self) -> Optional[pulumi.Input[bool]]: + return pulumi.get(self, "short_fields") + + @short_fields.setter + def short_fields(self, value: Optional[pulumi.Input[bool]]): + pulumi.set(self, "short_fields", value) + + @property + @pulumi.getter + def slug(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "slug") + + @slug.setter + def slug(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "slug", value) + + @property + @pulumi.getter + def text(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "text") + + @text.setter + def text(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "text", value) + + @property + @pulumi.getter(name="thumbUrl") + def thumb_url(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "thumb_url") + + @thumb_url.setter + def thumb_url(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "thumb_url", value) + + @property + @pulumi.getter + def title(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "title") + + @title.setter + def title(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "title", value) + + @property + @pulumi.getter(name="titleLink") + def title_link(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "title_link") + + @title_link.setter + def title_link(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "title_link", value) + + @property + @pulumi.getter(name="tlsInsecureSkipVerify") + def tls_insecure_skip_verify(self) -> Optional[pulumi.Input[bool]]: + return pulumi.get(self, "tls_insecure_skip_verify") + + @tls_insecure_skip_verify.setter + def tls_insecure_skip_verify(self, value: Optional[pulumi.Input[bool]]): + pulumi.set(self, "tls_insecure_skip_verify", value) + + @property + @pulumi.getter + def username(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "username") + + @username.setter + def username(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "username", value) + + +class SlackAlertNotifier(pulumi.CustomResource): + @overload + def __init__(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + actions: Optional[pulumi.Input[Sequence[pulumi.Input[pulumi.InputType['SlackAlertNotifierActionArgs']]]]] = None, + api_url: Optional[pulumi.Input[str]] = None, + basic_auth_password: Optional[pulumi.Input[str]] = None, + basic_auth_username: Optional[pulumi.Input[str]] = None, + bearer_token: Optional[pulumi.Input[str]] = None, + callback_id: Optional[pulumi.Input[str]] = None, + channel: Optional[pulumi.Input[str]] = None, + color: Optional[pulumi.Input[str]] = None, + fallback: Optional[pulumi.Input[str]] = None, + fields: Optional[pulumi.Input[Sequence[pulumi.Input[pulumi.InputType['SlackAlertNotifierFieldArgs']]]]] = None, + footer: Optional[pulumi.Input[str]] = None, + icon_emoji: Optional[pulumi.Input[str]] = None, + icon_url: Optional[pulumi.Input[str]] = None, + image_url: Optional[pulumi.Input[str]] = None, + link_names: Optional[pulumi.Input[bool]] = None, + mrkdwn_ins: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None, + name: Optional[pulumi.Input[str]] = None, + pretext: Optional[pulumi.Input[str]] = None, + proxy_url: Optional[pulumi.Input[str]] = None, + send_resolved: Optional[pulumi.Input[bool]] = None, + short_fields: Optional[pulumi.Input[bool]] = None, + slug: Optional[pulumi.Input[str]] = None, + text: Optional[pulumi.Input[str]] = None, + thumb_url: Optional[pulumi.Input[str]] = None, + title: Optional[pulumi.Input[str]] = None, + title_link: Optional[pulumi.Input[str]] = None, + tls_insecure_skip_verify: Optional[pulumi.Input[bool]] = None, + username: Optional[pulumi.Input[str]] = None, + __props__=None): + """ + Create a SlackAlertNotifier resource with the given unique name, props, and options. + :param str resource_name: The name of the resource. + :param pulumi.ResourceOptions opts: Options for the resource. + """ + ... + @overload + def __init__(__self__, + resource_name: str, + args: SlackAlertNotifierArgs, + opts: Optional[pulumi.ResourceOptions] = None): + """ + Create a SlackAlertNotifier resource with the given unique name, props, and options. + :param str resource_name: The name of the resource. + :param SlackAlertNotifierArgs 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(SlackAlertNotifierArgs, 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, + actions: Optional[pulumi.Input[Sequence[pulumi.Input[pulumi.InputType['SlackAlertNotifierActionArgs']]]]] = None, + api_url: Optional[pulumi.Input[str]] = None, + basic_auth_password: Optional[pulumi.Input[str]] = None, + basic_auth_username: Optional[pulumi.Input[str]] = None, + bearer_token: Optional[pulumi.Input[str]] = None, + callback_id: Optional[pulumi.Input[str]] = None, + channel: Optional[pulumi.Input[str]] = None, + color: Optional[pulumi.Input[str]] = None, + fallback: Optional[pulumi.Input[str]] = None, + fields: Optional[pulumi.Input[Sequence[pulumi.Input[pulumi.InputType['SlackAlertNotifierFieldArgs']]]]] = None, + footer: Optional[pulumi.Input[str]] = None, + icon_emoji: Optional[pulumi.Input[str]] = None, + icon_url: Optional[pulumi.Input[str]] = None, + image_url: Optional[pulumi.Input[str]] = None, + link_names: Optional[pulumi.Input[bool]] = None, + mrkdwn_ins: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None, + name: Optional[pulumi.Input[str]] = None, + pretext: Optional[pulumi.Input[str]] = None, + proxy_url: Optional[pulumi.Input[str]] = None, + send_resolved: Optional[pulumi.Input[bool]] = None, + short_fields: Optional[pulumi.Input[bool]] = None, + slug: Optional[pulumi.Input[str]] = None, + text: Optional[pulumi.Input[str]] = None, + thumb_url: Optional[pulumi.Input[str]] = None, + title: Optional[pulumi.Input[str]] = None, + title_link: Optional[pulumi.Input[str]] = None, + tls_insecure_skip_verify: Optional[pulumi.Input[bool]] = None, + username: Optional[pulumi.Input[str]] = None, + __props__=None): + opts = pulumi.ResourceOptions.merge(_utilities.get_resource_opts_defaults(), opts) + if not isinstance(opts, pulumi.ResourceOptions): + raise TypeError('Expected resource options to be a ResourceOptions instance') + if opts.id is None: + if __props__ is not None: + raise TypeError('__props__ is only valid when passed in combination with a valid opts.id to get an existing resource') + __props__ = SlackAlertNotifierArgs.__new__(SlackAlertNotifierArgs) + + __props__.__dict__["actions"] = actions + if api_url is None and not opts.urn: + raise TypeError("Missing required property 'api_url'") + __props__.__dict__["api_url"] = None if api_url is None else pulumi.Output.secret(api_url) + __props__.__dict__["basic_auth_password"] = None if basic_auth_password is None else pulumi.Output.secret(basic_auth_password) + __props__.__dict__["basic_auth_username"] = basic_auth_username + __props__.__dict__["bearer_token"] = bearer_token + __props__.__dict__["callback_id"] = callback_id + if channel is None and not opts.urn: + raise TypeError("Missing required property 'channel'") + __props__.__dict__["channel"] = channel + __props__.__dict__["color"] = color + __props__.__dict__["fallback"] = fallback + __props__.__dict__["fields"] = fields + __props__.__dict__["footer"] = footer + __props__.__dict__["icon_emoji"] = icon_emoji + __props__.__dict__["icon_url"] = icon_url + __props__.__dict__["image_url"] = image_url + __props__.__dict__["link_names"] = link_names + __props__.__dict__["mrkdwn_ins"] = mrkdwn_ins + if name is None and not opts.urn: + raise TypeError("Missing required property 'name'") + __props__.__dict__["name"] = name + __props__.__dict__["pretext"] = pretext + __props__.__dict__["proxy_url"] = proxy_url + __props__.__dict__["send_resolved"] = send_resolved + __props__.__dict__["short_fields"] = short_fields + __props__.__dict__["slug"] = slug + __props__.__dict__["text"] = text + __props__.__dict__["thumb_url"] = thumb_url + __props__.__dict__["title"] = title + __props__.__dict__["title_link"] = title_link + __props__.__dict__["tls_insecure_skip_verify"] = tls_insecure_skip_verify + __props__.__dict__["username"] = username + secret_opts = pulumi.ResourceOptions(additional_secret_outputs=["apiUrl", "basicAuthPassword"]) + opts = pulumi.ResourceOptions.merge(opts, secret_opts) + super(SlackAlertNotifier, __self__).__init__( + 'chronosphere:index/slackAlertNotifier:SlackAlertNotifier', + resource_name, + __props__, + opts) + + @staticmethod + def get(resource_name: str, + id: pulumi.Input[str], + opts: Optional[pulumi.ResourceOptions] = None, + actions: Optional[pulumi.Input[Sequence[pulumi.Input[pulumi.InputType['SlackAlertNotifierActionArgs']]]]] = None, + api_url: Optional[pulumi.Input[str]] = None, + basic_auth_password: Optional[pulumi.Input[str]] = None, + basic_auth_username: Optional[pulumi.Input[str]] = None, + bearer_token: Optional[pulumi.Input[str]] = None, + callback_id: Optional[pulumi.Input[str]] = None, + channel: Optional[pulumi.Input[str]] = None, + color: Optional[pulumi.Input[str]] = None, + fallback: Optional[pulumi.Input[str]] = None, + fields: Optional[pulumi.Input[Sequence[pulumi.Input[pulumi.InputType['SlackAlertNotifierFieldArgs']]]]] = None, + footer: Optional[pulumi.Input[str]] = None, + icon_emoji: Optional[pulumi.Input[str]] = None, + icon_url: Optional[pulumi.Input[str]] = None, + image_url: Optional[pulumi.Input[str]] = None, + link_names: Optional[pulumi.Input[bool]] = None, + mrkdwn_ins: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None, + name: Optional[pulumi.Input[str]] = None, + pretext: Optional[pulumi.Input[str]] = None, + proxy_url: Optional[pulumi.Input[str]] = None, + send_resolved: Optional[pulumi.Input[bool]] = None, + short_fields: Optional[pulumi.Input[bool]] = None, + slug: Optional[pulumi.Input[str]] = None, + text: Optional[pulumi.Input[str]] = None, + thumb_url: Optional[pulumi.Input[str]] = None, + title: Optional[pulumi.Input[str]] = None, + title_link: Optional[pulumi.Input[str]] = None, + tls_insecure_skip_verify: Optional[pulumi.Input[bool]] = None, + username: Optional[pulumi.Input[str]] = None) -> 'SlackAlertNotifier': + """ + Get an existing SlackAlertNotifier 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. + """ + opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id)) + + __props__ = _SlackAlertNotifierState.__new__(_SlackAlertNotifierState) + + __props__.__dict__["actions"] = actions + __props__.__dict__["api_url"] = api_url + __props__.__dict__["basic_auth_password"] = basic_auth_password + __props__.__dict__["basic_auth_username"] = basic_auth_username + __props__.__dict__["bearer_token"] = bearer_token + __props__.__dict__["callback_id"] = callback_id + __props__.__dict__["channel"] = channel + __props__.__dict__["color"] = color + __props__.__dict__["fallback"] = fallback + __props__.__dict__["fields"] = fields + __props__.__dict__["footer"] = footer + __props__.__dict__["icon_emoji"] = icon_emoji + __props__.__dict__["icon_url"] = icon_url + __props__.__dict__["image_url"] = image_url + __props__.__dict__["link_names"] = link_names + __props__.__dict__["mrkdwn_ins"] = mrkdwn_ins + __props__.__dict__["name"] = name + __props__.__dict__["pretext"] = pretext + __props__.__dict__["proxy_url"] = proxy_url + __props__.__dict__["send_resolved"] = send_resolved + __props__.__dict__["short_fields"] = short_fields + __props__.__dict__["slug"] = slug + __props__.__dict__["text"] = text + __props__.__dict__["thumb_url"] = thumb_url + __props__.__dict__["title"] = title + __props__.__dict__["title_link"] = title_link + __props__.__dict__["tls_insecure_skip_verify"] = tls_insecure_skip_verify + __props__.__dict__["username"] = username + return SlackAlertNotifier(resource_name, opts=opts, __props__=__props__) + + @property + @pulumi.getter + def actions(self) -> pulumi.Output[Optional[Sequence['outputs.SlackAlertNotifierAction']]]: + return pulumi.get(self, "actions") + + @property + @pulumi.getter(name="apiUrl") + def api_url(self) -> pulumi.Output[str]: + return pulumi.get(self, "api_url") + + @property + @pulumi.getter(name="basicAuthPassword") + def basic_auth_password(self) -> pulumi.Output[Optional[str]]: + return pulumi.get(self, "basic_auth_password") + + @property + @pulumi.getter(name="basicAuthUsername") + def basic_auth_username(self) -> pulumi.Output[Optional[str]]: + return pulumi.get(self, "basic_auth_username") + + @property + @pulumi.getter(name="bearerToken") + def bearer_token(self) -> pulumi.Output[Optional[str]]: + return pulumi.get(self, "bearer_token") + + @property + @pulumi.getter(name="callbackId") + def callback_id(self) -> pulumi.Output[Optional[str]]: + return pulumi.get(self, "callback_id") + + @property + @pulumi.getter + def channel(self) -> pulumi.Output[str]: + return pulumi.get(self, "channel") + + @property + @pulumi.getter + def color(self) -> pulumi.Output[Optional[str]]: + return pulumi.get(self, "color") + + @property + @pulumi.getter + def fallback(self) -> pulumi.Output[Optional[str]]: + return pulumi.get(self, "fallback") + + @property + @pulumi.getter + def fields(self) -> pulumi.Output[Optional[Sequence['outputs.SlackAlertNotifierField']]]: + return pulumi.get(self, "fields") + + @property + @pulumi.getter + def footer(self) -> pulumi.Output[Optional[str]]: + return pulumi.get(self, "footer") + + @property + @pulumi.getter(name="iconEmoji") + def icon_emoji(self) -> pulumi.Output[Optional[str]]: + return pulumi.get(self, "icon_emoji") + + @property + @pulumi.getter(name="iconUrl") + def icon_url(self) -> pulumi.Output[Optional[str]]: + return pulumi.get(self, "icon_url") + + @property + @pulumi.getter(name="imageUrl") + def image_url(self) -> pulumi.Output[Optional[str]]: + return pulumi.get(self, "image_url") + + @property + @pulumi.getter(name="linkNames") + def link_names(self) -> pulumi.Output[Optional[bool]]: + return pulumi.get(self, "link_names") + + @property + @pulumi.getter(name="mrkdwnIns") + def mrkdwn_ins(self) -> pulumi.Output[Optional[Sequence[str]]]: + return pulumi.get(self, "mrkdwn_ins") + + @property + @pulumi.getter + def name(self) -> pulumi.Output[str]: + return pulumi.get(self, "name") + + @property + @pulumi.getter + def pretext(self) -> pulumi.Output[Optional[str]]: + return pulumi.get(self, "pretext") + + @property + @pulumi.getter(name="proxyUrl") + def proxy_url(self) -> pulumi.Output[Optional[str]]: + return pulumi.get(self, "proxy_url") + + @property + @pulumi.getter(name="sendResolved") + def send_resolved(self) -> pulumi.Output[Optional[bool]]: + return pulumi.get(self, "send_resolved") + + @property + @pulumi.getter(name="shortFields") + def short_fields(self) -> pulumi.Output[Optional[bool]]: + return pulumi.get(self, "short_fields") + + @property + @pulumi.getter + def slug(self) -> pulumi.Output[str]: + return pulumi.get(self, "slug") + + @property + @pulumi.getter + def text(self) -> pulumi.Output[Optional[str]]: + return pulumi.get(self, "text") + + @property + @pulumi.getter(name="thumbUrl") + def thumb_url(self) -> pulumi.Output[Optional[str]]: + return pulumi.get(self, "thumb_url") + + @property + @pulumi.getter + def title(self) -> pulumi.Output[Optional[str]]: + return pulumi.get(self, "title") + + @property + @pulumi.getter(name="titleLink") + def title_link(self) -> pulumi.Output[Optional[str]]: + return pulumi.get(self, "title_link") + + @property + @pulumi.getter(name="tlsInsecureSkipVerify") + def tls_insecure_skip_verify(self) -> pulumi.Output[Optional[bool]]: + return pulumi.get(self, "tls_insecure_skip_verify") + + @property + @pulumi.getter + def username(self) -> pulumi.Output[Optional[str]]: + return pulumi.get(self, "username") + diff --git a/sdk/python/chronosphereio_chronosphere/team.py b/sdk/python/chronosphereio_chronosphere/team.py new file mode 100644 index 00000000..27524134 --- /dev/null +++ b/sdk/python/chronosphereio_chronosphere/team.py @@ -0,0 +1,233 @@ +# coding=utf-8 +# *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import copy +import warnings +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +from . import _utilities + +__all__ = ['TeamArgs', 'Team'] + +@pulumi.input_type +class TeamArgs: + def __init__(__self__, *, + name: pulumi.Input[str], + description: Optional[pulumi.Input[str]] = None, + slug: Optional[pulumi.Input[str]] = None, + user_emails: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None): + """ + The set of arguments for constructing a Team resource. + """ + pulumi.set(__self__, "name", name) + if description is not None: + pulumi.set(__self__, "description", description) + if slug is not None: + pulumi.set(__self__, "slug", slug) + if user_emails is not None: + pulumi.set(__self__, "user_emails", user_emails) + + @property + @pulumi.getter + def name(self) -> pulumi.Input[str]: + return pulumi.get(self, "name") + + @name.setter + def name(self, value: pulumi.Input[str]): + pulumi.set(self, "name", value) + + @property + @pulumi.getter + def description(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "description") + + @description.setter + def description(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "description", value) + + @property + @pulumi.getter + def slug(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "slug") + + @slug.setter + def slug(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "slug", value) + + @property + @pulumi.getter(name="userEmails") + def user_emails(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]: + return pulumi.get(self, "user_emails") + + @user_emails.setter + def user_emails(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]): + pulumi.set(self, "user_emails", value) + + +@pulumi.input_type +class _TeamState: + def __init__(__self__, *, + description: Optional[pulumi.Input[str]] = None, + name: Optional[pulumi.Input[str]] = None, + slug: Optional[pulumi.Input[str]] = None, + user_emails: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None): + """ + Input properties used for looking up and filtering Team resources. + """ + if description is not None: + pulumi.set(__self__, "description", description) + if name is not None: + pulumi.set(__self__, "name", name) + if slug is not None: + pulumi.set(__self__, "slug", slug) + if user_emails is not None: + pulumi.set(__self__, "user_emails", user_emails) + + @property + @pulumi.getter + def description(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "description") + + @description.setter + def description(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "description", value) + + @property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "name", value) + + @property + @pulumi.getter + def slug(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "slug") + + @slug.setter + def slug(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "slug", value) + + @property + @pulumi.getter(name="userEmails") + def user_emails(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]: + return pulumi.get(self, "user_emails") + + @user_emails.setter + def user_emails(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]): + pulumi.set(self, "user_emails", value) + + +class Team(pulumi.CustomResource): + @overload + def __init__(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + description: Optional[pulumi.Input[str]] = None, + name: Optional[pulumi.Input[str]] = None, + slug: Optional[pulumi.Input[str]] = None, + user_emails: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None, + __props__=None): + """ + Create a Team resource with the given unique name, props, and options. + :param str resource_name: The name of the resource. + :param pulumi.ResourceOptions opts: Options for the resource. + """ + ... + @overload + def __init__(__self__, + resource_name: str, + args: TeamArgs, + opts: Optional[pulumi.ResourceOptions] = None): + """ + Create a Team resource with the given unique name, props, and options. + :param str resource_name: The name of the resource. + :param TeamArgs 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(TeamArgs, 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[str]] = None, + name: Optional[pulumi.Input[str]] = None, + slug: Optional[pulumi.Input[str]] = None, + user_emails: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None, + __props__=None): + opts = pulumi.ResourceOptions.merge(_utilities.get_resource_opts_defaults(), opts) + if not isinstance(opts, pulumi.ResourceOptions): + raise TypeError('Expected resource options to be a ResourceOptions instance') + if opts.id is None: + if __props__ is not None: + raise TypeError('__props__ is only valid when passed in combination with a valid opts.id to get an existing resource') + __props__ = TeamArgs.__new__(TeamArgs) + + __props__.__dict__["description"] = description + if name is None and not opts.urn: + raise TypeError("Missing required property 'name'") + __props__.__dict__["name"] = name + __props__.__dict__["slug"] = slug + __props__.__dict__["user_emails"] = user_emails + super(Team, __self__).__init__( + 'chronosphere:index/team:Team', + resource_name, + __props__, + opts) + + @staticmethod + def get(resource_name: str, + id: pulumi.Input[str], + opts: Optional[pulumi.ResourceOptions] = None, + description: Optional[pulumi.Input[str]] = None, + name: Optional[pulumi.Input[str]] = None, + slug: Optional[pulumi.Input[str]] = None, + user_emails: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None) -> 'Team': + """ + Get an existing Team 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. + """ + opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id)) + + __props__ = _TeamState.__new__(_TeamState) + + __props__.__dict__["description"] = description + __props__.__dict__["name"] = name + __props__.__dict__["slug"] = slug + __props__.__dict__["user_emails"] = user_emails + return Team(resource_name, opts=opts, __props__=__props__) + + @property + @pulumi.getter + def description(self) -> pulumi.Output[Optional[str]]: + return pulumi.get(self, "description") + + @property + @pulumi.getter + def name(self) -> pulumi.Output[str]: + return pulumi.get(self, "name") + + @property + @pulumi.getter + def slug(self) -> pulumi.Output[str]: + return pulumi.get(self, "slug") + + @property + @pulumi.getter(name="userEmails") + def user_emails(self) -> pulumi.Output[Optional[Sequence[str]]]: + return pulumi.get(self, "user_emails") + diff --git a/sdk/python/chronosphereio_chronosphere/trace_jaeger_remote_sampling_strategy.py b/sdk/python/chronosphereio_chronosphere/trace_jaeger_remote_sampling_strategy.py new file mode 100644 index 00000000..74bdbfd4 --- /dev/null +++ b/sdk/python/chronosphereio_chronosphere/trace_jaeger_remote_sampling_strategy.py @@ -0,0 +1,237 @@ +# coding=utf-8 +# *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import copy +import warnings +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +from . import _utilities +from . import outputs +from ._inputs import * + +__all__ = ['TraceJaegerRemoteSamplingStrategyArgs', 'TraceJaegerRemoteSamplingStrategy'] + +@pulumi.input_type +class TraceJaegerRemoteSamplingStrategyArgs: + def __init__(__self__, *, + applied_strategy: pulumi.Input['TraceJaegerRemoteSamplingStrategyAppliedStrategyArgs'], + name: pulumi.Input[str], + service_name: pulumi.Input[str], + slug: Optional[pulumi.Input[str]] = None): + """ + The set of arguments for constructing a TraceJaegerRemoteSamplingStrategy resource. + """ + pulumi.set(__self__, "applied_strategy", applied_strategy) + pulumi.set(__self__, "name", name) + pulumi.set(__self__, "service_name", service_name) + if slug is not None: + pulumi.set(__self__, "slug", slug) + + @property + @pulumi.getter(name="appliedStrategy") + def applied_strategy(self) -> pulumi.Input['TraceJaegerRemoteSamplingStrategyAppliedStrategyArgs']: + return pulumi.get(self, "applied_strategy") + + @applied_strategy.setter + def applied_strategy(self, value: pulumi.Input['TraceJaegerRemoteSamplingStrategyAppliedStrategyArgs']): + pulumi.set(self, "applied_strategy", value) + + @property + @pulumi.getter + def name(self) -> pulumi.Input[str]: + return pulumi.get(self, "name") + + @name.setter + def name(self, value: pulumi.Input[str]): + pulumi.set(self, "name", value) + + @property + @pulumi.getter(name="serviceName") + def service_name(self) -> pulumi.Input[str]: + return pulumi.get(self, "service_name") + + @service_name.setter + def service_name(self, value: pulumi.Input[str]): + pulumi.set(self, "service_name", value) + + @property + @pulumi.getter + def slug(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "slug") + + @slug.setter + def slug(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "slug", value) + + +@pulumi.input_type +class _TraceJaegerRemoteSamplingStrategyState: + def __init__(__self__, *, + applied_strategy: Optional[pulumi.Input['TraceJaegerRemoteSamplingStrategyAppliedStrategyArgs']] = None, + name: Optional[pulumi.Input[str]] = None, + service_name: Optional[pulumi.Input[str]] = None, + slug: Optional[pulumi.Input[str]] = None): + """ + Input properties used for looking up and filtering TraceJaegerRemoteSamplingStrategy resources. + """ + if applied_strategy is not None: + pulumi.set(__self__, "applied_strategy", applied_strategy) + if name is not None: + pulumi.set(__self__, "name", name) + if service_name is not None: + pulumi.set(__self__, "service_name", service_name) + if slug is not None: + pulumi.set(__self__, "slug", slug) + + @property + @pulumi.getter(name="appliedStrategy") + def applied_strategy(self) -> Optional[pulumi.Input['TraceJaegerRemoteSamplingStrategyAppliedStrategyArgs']]: + return pulumi.get(self, "applied_strategy") + + @applied_strategy.setter + def applied_strategy(self, value: Optional[pulumi.Input['TraceJaegerRemoteSamplingStrategyAppliedStrategyArgs']]): + pulumi.set(self, "applied_strategy", value) + + @property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "name", value) + + @property + @pulumi.getter(name="serviceName") + def service_name(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "service_name") + + @service_name.setter + def service_name(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "service_name", value) + + @property + @pulumi.getter + def slug(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "slug") + + @slug.setter + def slug(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "slug", value) + + +class TraceJaegerRemoteSamplingStrategy(pulumi.CustomResource): + @overload + def __init__(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + applied_strategy: Optional[pulumi.Input[pulumi.InputType['TraceJaegerRemoteSamplingStrategyAppliedStrategyArgs']]] = None, + name: Optional[pulumi.Input[str]] = None, + service_name: Optional[pulumi.Input[str]] = None, + slug: Optional[pulumi.Input[str]] = None, + __props__=None): + """ + Create a TraceJaegerRemoteSamplingStrategy resource with the given unique name, props, and options. + :param str resource_name: The name of the resource. + :param pulumi.ResourceOptions opts: Options for the resource. + """ + ... + @overload + def __init__(__self__, + resource_name: str, + args: TraceJaegerRemoteSamplingStrategyArgs, + opts: Optional[pulumi.ResourceOptions] = None): + """ + Create a TraceJaegerRemoteSamplingStrategy resource with the given unique name, props, and options. + :param str resource_name: The name of the resource. + :param TraceJaegerRemoteSamplingStrategyArgs 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(TraceJaegerRemoteSamplingStrategyArgs, 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, + applied_strategy: Optional[pulumi.Input[pulumi.InputType['TraceJaegerRemoteSamplingStrategyAppliedStrategyArgs']]] = None, + name: Optional[pulumi.Input[str]] = None, + service_name: Optional[pulumi.Input[str]] = None, + slug: Optional[pulumi.Input[str]] = None, + __props__=None): + opts = pulumi.ResourceOptions.merge(_utilities.get_resource_opts_defaults(), opts) + if not isinstance(opts, pulumi.ResourceOptions): + raise TypeError('Expected resource options to be a ResourceOptions instance') + if opts.id is None: + if __props__ is not None: + raise TypeError('__props__ is only valid when passed in combination with a valid opts.id to get an existing resource') + __props__ = TraceJaegerRemoteSamplingStrategyArgs.__new__(TraceJaegerRemoteSamplingStrategyArgs) + + if applied_strategy is None and not opts.urn: + raise TypeError("Missing required property 'applied_strategy'") + __props__.__dict__["applied_strategy"] = applied_strategy + if name is None and not opts.urn: + raise TypeError("Missing required property 'name'") + __props__.__dict__["name"] = name + if service_name is None and not opts.urn: + raise TypeError("Missing required property 'service_name'") + __props__.__dict__["service_name"] = service_name + __props__.__dict__["slug"] = slug + super(TraceJaegerRemoteSamplingStrategy, __self__).__init__( + 'chronosphere:index/traceJaegerRemoteSamplingStrategy:TraceJaegerRemoteSamplingStrategy', + resource_name, + __props__, + opts) + + @staticmethod + def get(resource_name: str, + id: pulumi.Input[str], + opts: Optional[pulumi.ResourceOptions] = None, + applied_strategy: Optional[pulumi.Input[pulumi.InputType['TraceJaegerRemoteSamplingStrategyAppliedStrategyArgs']]] = None, + name: Optional[pulumi.Input[str]] = None, + service_name: Optional[pulumi.Input[str]] = None, + slug: Optional[pulumi.Input[str]] = None) -> 'TraceJaegerRemoteSamplingStrategy': + """ + Get an existing TraceJaegerRemoteSamplingStrategy 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. + """ + opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id)) + + __props__ = _TraceJaegerRemoteSamplingStrategyState.__new__(_TraceJaegerRemoteSamplingStrategyState) + + __props__.__dict__["applied_strategy"] = applied_strategy + __props__.__dict__["name"] = name + __props__.__dict__["service_name"] = service_name + __props__.__dict__["slug"] = slug + return TraceJaegerRemoteSamplingStrategy(resource_name, opts=opts, __props__=__props__) + + @property + @pulumi.getter(name="appliedStrategy") + def applied_strategy(self) -> pulumi.Output['outputs.TraceJaegerRemoteSamplingStrategyAppliedStrategy']: + return pulumi.get(self, "applied_strategy") + + @property + @pulumi.getter + def name(self) -> pulumi.Output[str]: + return pulumi.get(self, "name") + + @property + @pulumi.getter(name="serviceName") + def service_name(self) -> pulumi.Output[str]: + return pulumi.get(self, "service_name") + + @property + @pulumi.getter + def slug(self) -> pulumi.Output[str]: + return pulumi.get(self, "slug") + diff --git a/sdk/python/chronosphereio_chronosphere/trace_metrics_rule.py b/sdk/python/chronosphereio_chronosphere/trace_metrics_rule.py new file mode 100644 index 00000000..b7a3be28 --- /dev/null +++ b/sdk/python/chronosphereio_chronosphere/trace_metrics_rule.py @@ -0,0 +1,339 @@ +# coding=utf-8 +# *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import copy +import warnings +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +from . import _utilities +from . import outputs +from ._inputs import * + +__all__ = ['TraceMetricsRuleArgs', 'TraceMetricsRule'] + +@pulumi.input_type +class TraceMetricsRuleArgs: + def __init__(__self__, *, + metric_name: pulumi.Input[str], + name: pulumi.Input[str], + trace_filter: pulumi.Input['TraceMetricsRuleTraceFilterArgs'], + group_bies: Optional[pulumi.Input[Sequence[pulumi.Input['TraceMetricsRuleGroupByArgs']]]] = None, + histogram_buckets_seconds: Optional[pulumi.Input[Sequence[pulumi.Input[float]]]] = None, + metric_labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None, + slug: Optional[pulumi.Input[str]] = None): + """ + The set of arguments for constructing a TraceMetricsRule resource. + """ + pulumi.set(__self__, "metric_name", metric_name) + pulumi.set(__self__, "name", name) + pulumi.set(__self__, "trace_filter", trace_filter) + if group_bies is not None: + pulumi.set(__self__, "group_bies", group_bies) + if histogram_buckets_seconds is not None: + pulumi.set(__self__, "histogram_buckets_seconds", histogram_buckets_seconds) + if metric_labels is not None: + pulumi.set(__self__, "metric_labels", metric_labels) + if slug is not None: + pulumi.set(__self__, "slug", slug) + + @property + @pulumi.getter(name="metricName") + def metric_name(self) -> pulumi.Input[str]: + return pulumi.get(self, "metric_name") + + @metric_name.setter + def metric_name(self, value: pulumi.Input[str]): + pulumi.set(self, "metric_name", value) + + @property + @pulumi.getter + def name(self) -> pulumi.Input[str]: + return pulumi.get(self, "name") + + @name.setter + def name(self, value: pulumi.Input[str]): + pulumi.set(self, "name", value) + + @property + @pulumi.getter(name="traceFilter") + def trace_filter(self) -> pulumi.Input['TraceMetricsRuleTraceFilterArgs']: + return pulumi.get(self, "trace_filter") + + @trace_filter.setter + def trace_filter(self, value: pulumi.Input['TraceMetricsRuleTraceFilterArgs']): + pulumi.set(self, "trace_filter", value) + + @property + @pulumi.getter(name="groupBies") + def group_bies(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['TraceMetricsRuleGroupByArgs']]]]: + return pulumi.get(self, "group_bies") + + @group_bies.setter + def group_bies(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['TraceMetricsRuleGroupByArgs']]]]): + pulumi.set(self, "group_bies", value) + + @property + @pulumi.getter(name="histogramBucketsSeconds") + def histogram_buckets_seconds(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[float]]]]: + return pulumi.get(self, "histogram_buckets_seconds") + + @histogram_buckets_seconds.setter + def histogram_buckets_seconds(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[float]]]]): + pulumi.set(self, "histogram_buckets_seconds", value) + + @property + @pulumi.getter(name="metricLabels") + def metric_labels(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]: + return pulumi.get(self, "metric_labels") + + @metric_labels.setter + def metric_labels(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]): + pulumi.set(self, "metric_labels", value) + + @property + @pulumi.getter + def slug(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "slug") + + @slug.setter + def slug(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "slug", value) + + +@pulumi.input_type +class _TraceMetricsRuleState: + def __init__(__self__, *, + group_bies: Optional[pulumi.Input[Sequence[pulumi.Input['TraceMetricsRuleGroupByArgs']]]] = None, + histogram_buckets_seconds: Optional[pulumi.Input[Sequence[pulumi.Input[float]]]] = None, + metric_labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None, + metric_name: Optional[pulumi.Input[str]] = None, + name: Optional[pulumi.Input[str]] = None, + slug: Optional[pulumi.Input[str]] = None, + trace_filter: Optional[pulumi.Input['TraceMetricsRuleTraceFilterArgs']] = None): + """ + Input properties used for looking up and filtering TraceMetricsRule resources. + """ + if group_bies is not None: + pulumi.set(__self__, "group_bies", group_bies) + if histogram_buckets_seconds is not None: + pulumi.set(__self__, "histogram_buckets_seconds", histogram_buckets_seconds) + if metric_labels is not None: + pulumi.set(__self__, "metric_labels", metric_labels) + if metric_name is not None: + pulumi.set(__self__, "metric_name", metric_name) + if name is not None: + pulumi.set(__self__, "name", name) + if slug is not None: + pulumi.set(__self__, "slug", slug) + if trace_filter is not None: + pulumi.set(__self__, "trace_filter", trace_filter) + + @property + @pulumi.getter(name="groupBies") + def group_bies(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['TraceMetricsRuleGroupByArgs']]]]: + return pulumi.get(self, "group_bies") + + @group_bies.setter + def group_bies(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['TraceMetricsRuleGroupByArgs']]]]): + pulumi.set(self, "group_bies", value) + + @property + @pulumi.getter(name="histogramBucketsSeconds") + def histogram_buckets_seconds(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[float]]]]: + return pulumi.get(self, "histogram_buckets_seconds") + + @histogram_buckets_seconds.setter + def histogram_buckets_seconds(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[float]]]]): + pulumi.set(self, "histogram_buckets_seconds", value) + + @property + @pulumi.getter(name="metricLabels") + def metric_labels(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]: + return pulumi.get(self, "metric_labels") + + @metric_labels.setter + def metric_labels(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]): + pulumi.set(self, "metric_labels", value) + + @property + @pulumi.getter(name="metricName") + def metric_name(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "metric_name") + + @metric_name.setter + def metric_name(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "metric_name", value) + + @property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "name", value) + + @property + @pulumi.getter + def slug(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "slug") + + @slug.setter + def slug(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "slug", value) + + @property + @pulumi.getter(name="traceFilter") + def trace_filter(self) -> Optional[pulumi.Input['TraceMetricsRuleTraceFilterArgs']]: + return pulumi.get(self, "trace_filter") + + @trace_filter.setter + def trace_filter(self, value: Optional[pulumi.Input['TraceMetricsRuleTraceFilterArgs']]): + pulumi.set(self, "trace_filter", value) + + +class TraceMetricsRule(pulumi.CustomResource): + @overload + def __init__(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + group_bies: Optional[pulumi.Input[Sequence[pulumi.Input[pulumi.InputType['TraceMetricsRuleGroupByArgs']]]]] = None, + histogram_buckets_seconds: Optional[pulumi.Input[Sequence[pulumi.Input[float]]]] = None, + metric_labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None, + metric_name: Optional[pulumi.Input[str]] = None, + name: Optional[pulumi.Input[str]] = None, + slug: Optional[pulumi.Input[str]] = None, + trace_filter: Optional[pulumi.Input[pulumi.InputType['TraceMetricsRuleTraceFilterArgs']]] = None, + __props__=None): + """ + Create a TraceMetricsRule resource with the given unique name, props, and options. + :param str resource_name: The name of the resource. + :param pulumi.ResourceOptions opts: Options for the resource. + """ + ... + @overload + def __init__(__self__, + resource_name: str, + args: TraceMetricsRuleArgs, + opts: Optional[pulumi.ResourceOptions] = None): + """ + Create a TraceMetricsRule resource with the given unique name, props, and options. + :param str resource_name: The name of the resource. + :param TraceMetricsRuleArgs 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(TraceMetricsRuleArgs, 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, + group_bies: Optional[pulumi.Input[Sequence[pulumi.Input[pulumi.InputType['TraceMetricsRuleGroupByArgs']]]]] = None, + histogram_buckets_seconds: Optional[pulumi.Input[Sequence[pulumi.Input[float]]]] = None, + metric_labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None, + metric_name: Optional[pulumi.Input[str]] = None, + name: Optional[pulumi.Input[str]] = None, + slug: Optional[pulumi.Input[str]] = None, + trace_filter: Optional[pulumi.Input[pulumi.InputType['TraceMetricsRuleTraceFilterArgs']]] = 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__ = TraceMetricsRuleArgs.__new__(TraceMetricsRuleArgs) + + __props__.__dict__["group_bies"] = group_bies + __props__.__dict__["histogram_buckets_seconds"] = histogram_buckets_seconds + __props__.__dict__["metric_labels"] = metric_labels + if metric_name is None and not opts.urn: + raise TypeError("Missing required property 'metric_name'") + __props__.__dict__["metric_name"] = metric_name + if name is None and not opts.urn: + raise TypeError("Missing required property 'name'") + __props__.__dict__["name"] = name + __props__.__dict__["slug"] = slug + if trace_filter is None and not opts.urn: + raise TypeError("Missing required property 'trace_filter'") + __props__.__dict__["trace_filter"] = trace_filter + super(TraceMetricsRule, __self__).__init__( + 'chronosphere:index/traceMetricsRule:TraceMetricsRule', + resource_name, + __props__, + opts) + + @staticmethod + def get(resource_name: str, + id: pulumi.Input[str], + opts: Optional[pulumi.ResourceOptions] = None, + group_bies: Optional[pulumi.Input[Sequence[pulumi.Input[pulumi.InputType['TraceMetricsRuleGroupByArgs']]]]] = None, + histogram_buckets_seconds: Optional[pulumi.Input[Sequence[pulumi.Input[float]]]] = None, + metric_labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None, + metric_name: Optional[pulumi.Input[str]] = None, + name: Optional[pulumi.Input[str]] = None, + slug: Optional[pulumi.Input[str]] = None, + trace_filter: Optional[pulumi.Input[pulumi.InputType['TraceMetricsRuleTraceFilterArgs']]] = None) -> 'TraceMetricsRule': + """ + Get an existing TraceMetricsRule 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. + """ + opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id)) + + __props__ = _TraceMetricsRuleState.__new__(_TraceMetricsRuleState) + + __props__.__dict__["group_bies"] = group_bies + __props__.__dict__["histogram_buckets_seconds"] = histogram_buckets_seconds + __props__.__dict__["metric_labels"] = metric_labels + __props__.__dict__["metric_name"] = metric_name + __props__.__dict__["name"] = name + __props__.__dict__["slug"] = slug + __props__.__dict__["trace_filter"] = trace_filter + return TraceMetricsRule(resource_name, opts=opts, __props__=__props__) + + @property + @pulumi.getter(name="groupBies") + def group_bies(self) -> pulumi.Output[Optional[Sequence['outputs.TraceMetricsRuleGroupBy']]]: + return pulumi.get(self, "group_bies") + + @property + @pulumi.getter(name="histogramBucketsSeconds") + def histogram_buckets_seconds(self) -> pulumi.Output[Optional[Sequence[float]]]: + return pulumi.get(self, "histogram_buckets_seconds") + + @property + @pulumi.getter(name="metricLabels") + def metric_labels(self) -> pulumi.Output[Optional[Mapping[str, str]]]: + return pulumi.get(self, "metric_labels") + + @property + @pulumi.getter(name="metricName") + def metric_name(self) -> pulumi.Output[str]: + return pulumi.get(self, "metric_name") + + @property + @pulumi.getter + def name(self) -> pulumi.Output[str]: + return pulumi.get(self, "name") + + @property + @pulumi.getter + def slug(self) -> pulumi.Output[str]: + return pulumi.get(self, "slug") + + @property + @pulumi.getter(name="traceFilter") + def trace_filter(self) -> pulumi.Output['outputs.TraceMetricsRuleTraceFilter']: + return pulumi.get(self, "trace_filter") + diff --git a/sdk/python/chronosphereio_chronosphere/trace_tail_sampling_rules.py b/sdk/python/chronosphereio_chronosphere/trace_tail_sampling_rules.py new file mode 100644 index 00000000..297d9913 --- /dev/null +++ b/sdk/python/chronosphereio_chronosphere/trace_tail_sampling_rules.py @@ -0,0 +1,166 @@ +# coding=utf-8 +# *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import copy +import warnings +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +from . import _utilities +from . import outputs +from ._inputs import * + +__all__ = ['TraceTailSamplingRulesArgs', 'TraceTailSamplingRules'] + +@pulumi.input_type +class TraceTailSamplingRulesArgs: + def __init__(__self__, *, + default_sample_rate: Optional[pulumi.Input['TraceTailSamplingRulesDefaultSampleRateArgs']] = None, + rules: Optional[pulumi.Input[Sequence[pulumi.Input['TraceTailSamplingRulesRuleArgs']]]] = None): + """ + The set of arguments for constructing a TraceTailSamplingRules resource. + """ + if default_sample_rate is not None: + pulumi.set(__self__, "default_sample_rate", default_sample_rate) + if rules is not None: + pulumi.set(__self__, "rules", rules) + + @property + @pulumi.getter(name="defaultSampleRate") + def default_sample_rate(self) -> Optional[pulumi.Input['TraceTailSamplingRulesDefaultSampleRateArgs']]: + return pulumi.get(self, "default_sample_rate") + + @default_sample_rate.setter + def default_sample_rate(self, value: Optional[pulumi.Input['TraceTailSamplingRulesDefaultSampleRateArgs']]): + pulumi.set(self, "default_sample_rate", value) + + @property + @pulumi.getter + def rules(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['TraceTailSamplingRulesRuleArgs']]]]: + return pulumi.get(self, "rules") + + @rules.setter + def rules(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['TraceTailSamplingRulesRuleArgs']]]]): + pulumi.set(self, "rules", value) + + +@pulumi.input_type +class _TraceTailSamplingRulesState: + def __init__(__self__, *, + default_sample_rate: Optional[pulumi.Input['TraceTailSamplingRulesDefaultSampleRateArgs']] = None, + rules: Optional[pulumi.Input[Sequence[pulumi.Input['TraceTailSamplingRulesRuleArgs']]]] = None): + """ + Input properties used for looking up and filtering TraceTailSamplingRules resources. + """ + if default_sample_rate is not None: + pulumi.set(__self__, "default_sample_rate", default_sample_rate) + if rules is not None: + pulumi.set(__self__, "rules", rules) + + @property + @pulumi.getter(name="defaultSampleRate") + def default_sample_rate(self) -> Optional[pulumi.Input['TraceTailSamplingRulesDefaultSampleRateArgs']]: + return pulumi.get(self, "default_sample_rate") + + @default_sample_rate.setter + def default_sample_rate(self, value: Optional[pulumi.Input['TraceTailSamplingRulesDefaultSampleRateArgs']]): + pulumi.set(self, "default_sample_rate", value) + + @property + @pulumi.getter + def rules(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['TraceTailSamplingRulesRuleArgs']]]]: + return pulumi.get(self, "rules") + + @rules.setter + def rules(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['TraceTailSamplingRulesRuleArgs']]]]): + pulumi.set(self, "rules", value) + + +class TraceTailSamplingRules(pulumi.CustomResource): + @overload + def __init__(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + default_sample_rate: Optional[pulumi.Input[pulumi.InputType['TraceTailSamplingRulesDefaultSampleRateArgs']]] = None, + rules: Optional[pulumi.Input[Sequence[pulumi.Input[pulumi.InputType['TraceTailSamplingRulesRuleArgs']]]]] = None, + __props__=None): + """ + Create a TraceTailSamplingRules resource with the given unique name, props, and options. + :param str resource_name: The name of the resource. + :param pulumi.ResourceOptions opts: Options for the resource. + """ + ... + @overload + def __init__(__self__, + resource_name: str, + args: Optional[TraceTailSamplingRulesArgs] = None, + opts: Optional[pulumi.ResourceOptions] = None): + """ + Create a TraceTailSamplingRules resource with the given unique name, props, and options. + :param str resource_name: The name of the resource. + :param TraceTailSamplingRulesArgs 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(TraceTailSamplingRulesArgs, 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_sample_rate: Optional[pulumi.Input[pulumi.InputType['TraceTailSamplingRulesDefaultSampleRateArgs']]] = None, + rules: Optional[pulumi.Input[Sequence[pulumi.Input[pulumi.InputType['TraceTailSamplingRulesRuleArgs']]]]] = 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__ = TraceTailSamplingRulesArgs.__new__(TraceTailSamplingRulesArgs) + + __props__.__dict__["default_sample_rate"] = default_sample_rate + __props__.__dict__["rules"] = rules + super(TraceTailSamplingRules, __self__).__init__( + 'chronosphere:index/traceTailSamplingRules:TraceTailSamplingRules', + resource_name, + __props__, + opts) + + @staticmethod + def get(resource_name: str, + id: pulumi.Input[str], + opts: Optional[pulumi.ResourceOptions] = None, + default_sample_rate: Optional[pulumi.Input[pulumi.InputType['TraceTailSamplingRulesDefaultSampleRateArgs']]] = None, + rules: Optional[pulumi.Input[Sequence[pulumi.Input[pulumi.InputType['TraceTailSamplingRulesRuleArgs']]]]] = None) -> 'TraceTailSamplingRules': + """ + Get an existing TraceTailSamplingRules 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. + """ + opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id)) + + __props__ = _TraceTailSamplingRulesState.__new__(_TraceTailSamplingRulesState) + + __props__.__dict__["default_sample_rate"] = default_sample_rate + __props__.__dict__["rules"] = rules + return TraceTailSamplingRules(resource_name, opts=opts, __props__=__props__) + + @property + @pulumi.getter(name="defaultSampleRate") + def default_sample_rate(self) -> pulumi.Output[Optional['outputs.TraceTailSamplingRulesDefaultSampleRate']]: + return pulumi.get(self, "default_sample_rate") + + @property + @pulumi.getter + def rules(self) -> pulumi.Output[Optional[Sequence['outputs.TraceTailSamplingRulesRule']]]: + return pulumi.get(self, "rules") + diff --git a/sdk/python/chronosphereio_chronosphere/victorops_alert_notifier.py b/sdk/python/chronosphereio_chronosphere/victorops_alert_notifier.py new file mode 100644 index 00000000..80bea34a --- /dev/null +++ b/sdk/python/chronosphereio_chronosphere/victorops_alert_notifier.py @@ -0,0 +1,645 @@ +# coding=utf-8 +# *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import copy +import warnings +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +from . import _utilities + +__all__ = ['VictoropsAlertNotifierArgs', 'VictoropsAlertNotifier'] + +@pulumi.input_type +class VictoropsAlertNotifierArgs: + def __init__(__self__, *, + api_key: pulumi.Input[str], + name: pulumi.Input[str], + routing_key: pulumi.Input[str], + api_url: Optional[pulumi.Input[str]] = None, + basic_auth_password: Optional[pulumi.Input[str]] = None, + basic_auth_username: Optional[pulumi.Input[str]] = None, + bearer_token: Optional[pulumi.Input[str]] = None, + custom_fields: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None, + entity_display_name: Optional[pulumi.Input[str]] = None, + message_type: Optional[pulumi.Input[str]] = None, + monitoring_tool: Optional[pulumi.Input[str]] = None, + proxy_url: Optional[pulumi.Input[str]] = None, + send_resolved: Optional[pulumi.Input[bool]] = None, + slug: Optional[pulumi.Input[str]] = None, + state_message: Optional[pulumi.Input[str]] = None, + tls_insecure_skip_verify: Optional[pulumi.Input[bool]] = None): + """ + The set of arguments for constructing a VictoropsAlertNotifier resource. + """ + pulumi.set(__self__, "api_key", api_key) + pulumi.set(__self__, "name", name) + pulumi.set(__self__, "routing_key", routing_key) + if api_url is not None: + pulumi.set(__self__, "api_url", api_url) + if basic_auth_password is not None: + pulumi.set(__self__, "basic_auth_password", basic_auth_password) + if basic_auth_username is not None: + pulumi.set(__self__, "basic_auth_username", basic_auth_username) + if bearer_token is not None: + pulumi.set(__self__, "bearer_token", bearer_token) + if custom_fields is not None: + pulumi.set(__self__, "custom_fields", custom_fields) + if entity_display_name is not None: + pulumi.set(__self__, "entity_display_name", entity_display_name) + if message_type is not None: + pulumi.set(__self__, "message_type", message_type) + if monitoring_tool is not None: + pulumi.set(__self__, "monitoring_tool", monitoring_tool) + if proxy_url is not None: + pulumi.set(__self__, "proxy_url", proxy_url) + if send_resolved is not None: + pulumi.set(__self__, "send_resolved", send_resolved) + if slug is not None: + pulumi.set(__self__, "slug", slug) + if state_message is not None: + pulumi.set(__self__, "state_message", state_message) + if tls_insecure_skip_verify is not None: + pulumi.set(__self__, "tls_insecure_skip_verify", tls_insecure_skip_verify) + + @property + @pulumi.getter(name="apiKey") + def api_key(self) -> pulumi.Input[str]: + return pulumi.get(self, "api_key") + + @api_key.setter + def api_key(self, value: pulumi.Input[str]): + pulumi.set(self, "api_key", value) + + @property + @pulumi.getter + def name(self) -> pulumi.Input[str]: + return pulumi.get(self, "name") + + @name.setter + def name(self, value: pulumi.Input[str]): + pulumi.set(self, "name", value) + + @property + @pulumi.getter(name="routingKey") + def routing_key(self) -> pulumi.Input[str]: + return pulumi.get(self, "routing_key") + + @routing_key.setter + def routing_key(self, value: pulumi.Input[str]): + pulumi.set(self, "routing_key", value) + + @property + @pulumi.getter(name="apiUrl") + def api_url(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "api_url") + + @api_url.setter + def api_url(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "api_url", value) + + @property + @pulumi.getter(name="basicAuthPassword") + def basic_auth_password(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "basic_auth_password") + + @basic_auth_password.setter + def basic_auth_password(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "basic_auth_password", value) + + @property + @pulumi.getter(name="basicAuthUsername") + def basic_auth_username(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "basic_auth_username") + + @basic_auth_username.setter + def basic_auth_username(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "basic_auth_username", value) + + @property + @pulumi.getter(name="bearerToken") + def bearer_token(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "bearer_token") + + @bearer_token.setter + def bearer_token(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "bearer_token", value) + + @property + @pulumi.getter(name="customFields") + def custom_fields(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]: + return pulumi.get(self, "custom_fields") + + @custom_fields.setter + def custom_fields(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]): + pulumi.set(self, "custom_fields", value) + + @property + @pulumi.getter(name="entityDisplayName") + def entity_display_name(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "entity_display_name") + + @entity_display_name.setter + def entity_display_name(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "entity_display_name", value) + + @property + @pulumi.getter(name="messageType") + def message_type(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "message_type") + + @message_type.setter + def message_type(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "message_type", value) + + @property + @pulumi.getter(name="monitoringTool") + def monitoring_tool(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "monitoring_tool") + + @monitoring_tool.setter + def monitoring_tool(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "monitoring_tool", value) + + @property + @pulumi.getter(name="proxyUrl") + def proxy_url(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "proxy_url") + + @proxy_url.setter + def proxy_url(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "proxy_url", value) + + @property + @pulumi.getter(name="sendResolved") + def send_resolved(self) -> Optional[pulumi.Input[bool]]: + return pulumi.get(self, "send_resolved") + + @send_resolved.setter + def send_resolved(self, value: Optional[pulumi.Input[bool]]): + pulumi.set(self, "send_resolved", value) + + @property + @pulumi.getter + def slug(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "slug") + + @slug.setter + def slug(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "slug", value) + + @property + @pulumi.getter(name="stateMessage") + def state_message(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "state_message") + + @state_message.setter + def state_message(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "state_message", value) + + @property + @pulumi.getter(name="tlsInsecureSkipVerify") + def tls_insecure_skip_verify(self) -> Optional[pulumi.Input[bool]]: + return pulumi.get(self, "tls_insecure_skip_verify") + + @tls_insecure_skip_verify.setter + def tls_insecure_skip_verify(self, value: Optional[pulumi.Input[bool]]): + pulumi.set(self, "tls_insecure_skip_verify", value) + + +@pulumi.input_type +class _VictoropsAlertNotifierState: + def __init__(__self__, *, + api_key: Optional[pulumi.Input[str]] = None, + api_url: Optional[pulumi.Input[str]] = None, + basic_auth_password: Optional[pulumi.Input[str]] = None, + basic_auth_username: Optional[pulumi.Input[str]] = None, + bearer_token: Optional[pulumi.Input[str]] = None, + custom_fields: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None, + entity_display_name: Optional[pulumi.Input[str]] = None, + message_type: Optional[pulumi.Input[str]] = None, + monitoring_tool: Optional[pulumi.Input[str]] = None, + name: Optional[pulumi.Input[str]] = None, + proxy_url: Optional[pulumi.Input[str]] = None, + routing_key: Optional[pulumi.Input[str]] = None, + send_resolved: Optional[pulumi.Input[bool]] = None, + slug: Optional[pulumi.Input[str]] = None, + state_message: Optional[pulumi.Input[str]] = None, + tls_insecure_skip_verify: Optional[pulumi.Input[bool]] = None): + """ + Input properties used for looking up and filtering VictoropsAlertNotifier resources. + """ + 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 basic_auth_password is not None: + pulumi.set(__self__, "basic_auth_password", basic_auth_password) + if basic_auth_username is not None: + pulumi.set(__self__, "basic_auth_username", basic_auth_username) + if bearer_token is not None: + pulumi.set(__self__, "bearer_token", bearer_token) + if custom_fields is not None: + pulumi.set(__self__, "custom_fields", custom_fields) + if entity_display_name is not None: + pulumi.set(__self__, "entity_display_name", entity_display_name) + if message_type is not None: + pulumi.set(__self__, "message_type", message_type) + if monitoring_tool is not None: + pulumi.set(__self__, "monitoring_tool", monitoring_tool) + if name is not None: + pulumi.set(__self__, "name", name) + if proxy_url is not None: + pulumi.set(__self__, "proxy_url", proxy_url) + if routing_key is not None: + pulumi.set(__self__, "routing_key", routing_key) + if send_resolved is not None: + pulumi.set(__self__, "send_resolved", send_resolved) + if slug is not None: + pulumi.set(__self__, "slug", slug) + if state_message is not None: + pulumi.set(__self__, "state_message", state_message) + if tls_insecure_skip_verify is not None: + pulumi.set(__self__, "tls_insecure_skip_verify", tls_insecure_skip_verify) + + @property + @pulumi.getter(name="apiKey") + def api_key(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "api_key") + + @api_key.setter + def api_key(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "api_key", value) + + @property + @pulumi.getter(name="apiUrl") + def api_url(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "api_url") + + @api_url.setter + def api_url(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "api_url", value) + + @property + @pulumi.getter(name="basicAuthPassword") + def basic_auth_password(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "basic_auth_password") + + @basic_auth_password.setter + def basic_auth_password(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "basic_auth_password", value) + + @property + @pulumi.getter(name="basicAuthUsername") + def basic_auth_username(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "basic_auth_username") + + @basic_auth_username.setter + def basic_auth_username(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "basic_auth_username", value) + + @property + @pulumi.getter(name="bearerToken") + def bearer_token(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "bearer_token") + + @bearer_token.setter + def bearer_token(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "bearer_token", value) + + @property + @pulumi.getter(name="customFields") + def custom_fields(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]: + return pulumi.get(self, "custom_fields") + + @custom_fields.setter + def custom_fields(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]): + pulumi.set(self, "custom_fields", value) + + @property + @pulumi.getter(name="entityDisplayName") + def entity_display_name(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "entity_display_name") + + @entity_display_name.setter + def entity_display_name(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "entity_display_name", value) + + @property + @pulumi.getter(name="messageType") + def message_type(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "message_type") + + @message_type.setter + def message_type(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "message_type", value) + + @property + @pulumi.getter(name="monitoringTool") + def monitoring_tool(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "monitoring_tool") + + @monitoring_tool.setter + def monitoring_tool(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "monitoring_tool", value) + + @property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "name", value) + + @property + @pulumi.getter(name="proxyUrl") + def proxy_url(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "proxy_url") + + @proxy_url.setter + def proxy_url(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "proxy_url", value) + + @property + @pulumi.getter(name="routingKey") + def routing_key(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "routing_key") + + @routing_key.setter + def routing_key(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "routing_key", value) + + @property + @pulumi.getter(name="sendResolved") + def send_resolved(self) -> Optional[pulumi.Input[bool]]: + return pulumi.get(self, "send_resolved") + + @send_resolved.setter + def send_resolved(self, value: Optional[pulumi.Input[bool]]): + pulumi.set(self, "send_resolved", value) + + @property + @pulumi.getter + def slug(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "slug") + + @slug.setter + def slug(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "slug", value) + + @property + @pulumi.getter(name="stateMessage") + def state_message(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "state_message") + + @state_message.setter + def state_message(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "state_message", value) + + @property + @pulumi.getter(name="tlsInsecureSkipVerify") + def tls_insecure_skip_verify(self) -> Optional[pulumi.Input[bool]]: + return pulumi.get(self, "tls_insecure_skip_verify") + + @tls_insecure_skip_verify.setter + def tls_insecure_skip_verify(self, value: Optional[pulumi.Input[bool]]): + pulumi.set(self, "tls_insecure_skip_verify", value) + + +class VictoropsAlertNotifier(pulumi.CustomResource): + @overload + def __init__(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + api_key: Optional[pulumi.Input[str]] = None, + api_url: Optional[pulumi.Input[str]] = None, + basic_auth_password: Optional[pulumi.Input[str]] = None, + basic_auth_username: Optional[pulumi.Input[str]] = None, + bearer_token: Optional[pulumi.Input[str]] = None, + custom_fields: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None, + entity_display_name: Optional[pulumi.Input[str]] = None, + message_type: Optional[pulumi.Input[str]] = None, + monitoring_tool: Optional[pulumi.Input[str]] = None, + name: Optional[pulumi.Input[str]] = None, + proxy_url: Optional[pulumi.Input[str]] = None, + routing_key: Optional[pulumi.Input[str]] = None, + send_resolved: Optional[pulumi.Input[bool]] = None, + slug: Optional[pulumi.Input[str]] = None, + state_message: Optional[pulumi.Input[str]] = None, + tls_insecure_skip_verify: Optional[pulumi.Input[bool]] = None, + __props__=None): + """ + Create a VictoropsAlertNotifier resource with the given unique name, props, and options. + :param str resource_name: The name of the resource. + :param pulumi.ResourceOptions opts: Options for the resource. + """ + ... + @overload + def __init__(__self__, + resource_name: str, + args: VictoropsAlertNotifierArgs, + opts: Optional[pulumi.ResourceOptions] = None): + """ + Create a VictoropsAlertNotifier resource with the given unique name, props, and options. + :param str resource_name: The name of the resource. + :param VictoropsAlertNotifierArgs 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(VictoropsAlertNotifierArgs, 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, + api_key: Optional[pulumi.Input[str]] = None, + api_url: Optional[pulumi.Input[str]] = None, + basic_auth_password: Optional[pulumi.Input[str]] = None, + basic_auth_username: Optional[pulumi.Input[str]] = None, + bearer_token: Optional[pulumi.Input[str]] = None, + custom_fields: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None, + entity_display_name: Optional[pulumi.Input[str]] = None, + message_type: Optional[pulumi.Input[str]] = None, + monitoring_tool: Optional[pulumi.Input[str]] = None, + name: Optional[pulumi.Input[str]] = None, + proxy_url: Optional[pulumi.Input[str]] = None, + routing_key: Optional[pulumi.Input[str]] = None, + send_resolved: Optional[pulumi.Input[bool]] = None, + slug: Optional[pulumi.Input[str]] = None, + state_message: Optional[pulumi.Input[str]] = None, + tls_insecure_skip_verify: Optional[pulumi.Input[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__ = VictoropsAlertNotifierArgs.__new__(VictoropsAlertNotifierArgs) + + if api_key is None and not opts.urn: + raise TypeError("Missing required property 'api_key'") + __props__.__dict__["api_key"] = None if api_key is None else pulumi.Output.secret(api_key) + __props__.__dict__["api_url"] = api_url + __props__.__dict__["basic_auth_password"] = None if basic_auth_password is None else pulumi.Output.secret(basic_auth_password) + __props__.__dict__["basic_auth_username"] = basic_auth_username + __props__.__dict__["bearer_token"] = bearer_token + __props__.__dict__["custom_fields"] = custom_fields + __props__.__dict__["entity_display_name"] = entity_display_name + __props__.__dict__["message_type"] = message_type + __props__.__dict__["monitoring_tool"] = monitoring_tool + if name is None and not opts.urn: + raise TypeError("Missing required property 'name'") + __props__.__dict__["name"] = name + __props__.__dict__["proxy_url"] = proxy_url + if routing_key is None and not opts.urn: + raise TypeError("Missing required property 'routing_key'") + __props__.__dict__["routing_key"] = routing_key + __props__.__dict__["send_resolved"] = send_resolved + __props__.__dict__["slug"] = slug + __props__.__dict__["state_message"] = state_message + __props__.__dict__["tls_insecure_skip_verify"] = tls_insecure_skip_verify + secret_opts = pulumi.ResourceOptions(additional_secret_outputs=["apiKey", "basicAuthPassword"]) + opts = pulumi.ResourceOptions.merge(opts, secret_opts) + super(VictoropsAlertNotifier, __self__).__init__( + 'chronosphere:index/victoropsAlertNotifier:VictoropsAlertNotifier', + resource_name, + __props__, + opts) + + @staticmethod + def get(resource_name: str, + id: pulumi.Input[str], + opts: Optional[pulumi.ResourceOptions] = None, + api_key: Optional[pulumi.Input[str]] = None, + api_url: Optional[pulumi.Input[str]] = None, + basic_auth_password: Optional[pulumi.Input[str]] = None, + basic_auth_username: Optional[pulumi.Input[str]] = None, + bearer_token: Optional[pulumi.Input[str]] = None, + custom_fields: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None, + entity_display_name: Optional[pulumi.Input[str]] = None, + message_type: Optional[pulumi.Input[str]] = None, + monitoring_tool: Optional[pulumi.Input[str]] = None, + name: Optional[pulumi.Input[str]] = None, + proxy_url: Optional[pulumi.Input[str]] = None, + routing_key: Optional[pulumi.Input[str]] = None, + send_resolved: Optional[pulumi.Input[bool]] = None, + slug: Optional[pulumi.Input[str]] = None, + state_message: Optional[pulumi.Input[str]] = None, + tls_insecure_skip_verify: Optional[pulumi.Input[bool]] = None) -> 'VictoropsAlertNotifier': + """ + Get an existing VictoropsAlertNotifier 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. + """ + opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id)) + + __props__ = _VictoropsAlertNotifierState.__new__(_VictoropsAlertNotifierState) + + __props__.__dict__["api_key"] = api_key + __props__.__dict__["api_url"] = api_url + __props__.__dict__["basic_auth_password"] = basic_auth_password + __props__.__dict__["basic_auth_username"] = basic_auth_username + __props__.__dict__["bearer_token"] = bearer_token + __props__.__dict__["custom_fields"] = custom_fields + __props__.__dict__["entity_display_name"] = entity_display_name + __props__.__dict__["message_type"] = message_type + __props__.__dict__["monitoring_tool"] = monitoring_tool + __props__.__dict__["name"] = name + __props__.__dict__["proxy_url"] = proxy_url + __props__.__dict__["routing_key"] = routing_key + __props__.__dict__["send_resolved"] = send_resolved + __props__.__dict__["slug"] = slug + __props__.__dict__["state_message"] = state_message + __props__.__dict__["tls_insecure_skip_verify"] = tls_insecure_skip_verify + return VictoropsAlertNotifier(resource_name, opts=opts, __props__=__props__) + + @property + @pulumi.getter(name="apiKey") + def api_key(self) -> pulumi.Output[str]: + return pulumi.get(self, "api_key") + + @property + @pulumi.getter(name="apiUrl") + def api_url(self) -> pulumi.Output[Optional[str]]: + return pulumi.get(self, "api_url") + + @property + @pulumi.getter(name="basicAuthPassword") + def basic_auth_password(self) -> pulumi.Output[Optional[str]]: + return pulumi.get(self, "basic_auth_password") + + @property + @pulumi.getter(name="basicAuthUsername") + def basic_auth_username(self) -> pulumi.Output[Optional[str]]: + return pulumi.get(self, "basic_auth_username") + + @property + @pulumi.getter(name="bearerToken") + def bearer_token(self) -> pulumi.Output[Optional[str]]: + return pulumi.get(self, "bearer_token") + + @property + @pulumi.getter(name="customFields") + def custom_fields(self) -> pulumi.Output[Optional[Mapping[str, str]]]: + return pulumi.get(self, "custom_fields") + + @property + @pulumi.getter(name="entityDisplayName") + def entity_display_name(self) -> pulumi.Output[Optional[str]]: + return pulumi.get(self, "entity_display_name") + + @property + @pulumi.getter(name="messageType") + def message_type(self) -> pulumi.Output[Optional[str]]: + return pulumi.get(self, "message_type") + + @property + @pulumi.getter(name="monitoringTool") + def monitoring_tool(self) -> pulumi.Output[Optional[str]]: + return pulumi.get(self, "monitoring_tool") + + @property + @pulumi.getter + def name(self) -> pulumi.Output[str]: + return pulumi.get(self, "name") + + @property + @pulumi.getter(name="proxyUrl") + def proxy_url(self) -> pulumi.Output[Optional[str]]: + return pulumi.get(self, "proxy_url") + + @property + @pulumi.getter(name="routingKey") + def routing_key(self) -> pulumi.Output[str]: + return pulumi.get(self, "routing_key") + + @property + @pulumi.getter(name="sendResolved") + def send_resolved(self) -> pulumi.Output[Optional[bool]]: + return pulumi.get(self, "send_resolved") + + @property + @pulumi.getter + def slug(self) -> pulumi.Output[str]: + return pulumi.get(self, "slug") + + @property + @pulumi.getter(name="stateMessage") + def state_message(self) -> pulumi.Output[Optional[str]]: + return pulumi.get(self, "state_message") + + @property + @pulumi.getter(name="tlsInsecureSkipVerify") + def tls_insecure_skip_verify(self) -> pulumi.Output[Optional[bool]]: + return pulumi.get(self, "tls_insecure_skip_verify") + diff --git a/sdk/python/chronosphereio_chronosphere/webhook_alert_notifier.py b/sdk/python/chronosphereio_chronosphere/webhook_alert_notifier.py new file mode 100644 index 00000000..9958ce1d --- /dev/null +++ b/sdk/python/chronosphereio_chronosphere/webhook_alert_notifier.py @@ -0,0 +1,406 @@ +# coding=utf-8 +# *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import copy +import warnings +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +from . import _utilities + +__all__ = ['WebhookAlertNotifierArgs', 'WebhookAlertNotifier'] + +@pulumi.input_type +class WebhookAlertNotifierArgs: + def __init__(__self__, *, + name: pulumi.Input[str], + url: pulumi.Input[str], + basic_auth_password: Optional[pulumi.Input[str]] = None, + basic_auth_username: Optional[pulumi.Input[str]] = None, + bearer_token: Optional[pulumi.Input[str]] = None, + proxy_url: Optional[pulumi.Input[str]] = None, + send_resolved: Optional[pulumi.Input[bool]] = None, + slug: Optional[pulumi.Input[str]] = None, + tls_insecure_skip_verify: Optional[pulumi.Input[bool]] = None): + """ + The set of arguments for constructing a WebhookAlertNotifier resource. + """ + pulumi.set(__self__, "name", name) + pulumi.set(__self__, "url", url) + if basic_auth_password is not None: + pulumi.set(__self__, "basic_auth_password", basic_auth_password) + if basic_auth_username is not None: + pulumi.set(__self__, "basic_auth_username", basic_auth_username) + if bearer_token is not None: + pulumi.set(__self__, "bearer_token", bearer_token) + if proxy_url is not None: + pulumi.set(__self__, "proxy_url", proxy_url) + if send_resolved is not None: + pulumi.set(__self__, "send_resolved", send_resolved) + if slug is not None: + pulumi.set(__self__, "slug", slug) + if tls_insecure_skip_verify is not None: + pulumi.set(__self__, "tls_insecure_skip_verify", tls_insecure_skip_verify) + + @property + @pulumi.getter + def name(self) -> pulumi.Input[str]: + return pulumi.get(self, "name") + + @name.setter + def name(self, value: pulumi.Input[str]): + pulumi.set(self, "name", value) + + @property + @pulumi.getter + def url(self) -> pulumi.Input[str]: + return pulumi.get(self, "url") + + @url.setter + def url(self, value: pulumi.Input[str]): + pulumi.set(self, "url", value) + + @property + @pulumi.getter(name="basicAuthPassword") + def basic_auth_password(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "basic_auth_password") + + @basic_auth_password.setter + def basic_auth_password(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "basic_auth_password", value) + + @property + @pulumi.getter(name="basicAuthUsername") + def basic_auth_username(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "basic_auth_username") + + @basic_auth_username.setter + def basic_auth_username(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "basic_auth_username", value) + + @property + @pulumi.getter(name="bearerToken") + def bearer_token(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "bearer_token") + + @bearer_token.setter + def bearer_token(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "bearer_token", value) + + @property + @pulumi.getter(name="proxyUrl") + def proxy_url(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "proxy_url") + + @proxy_url.setter + def proxy_url(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "proxy_url", value) + + @property + @pulumi.getter(name="sendResolved") + def send_resolved(self) -> Optional[pulumi.Input[bool]]: + return pulumi.get(self, "send_resolved") + + @send_resolved.setter + def send_resolved(self, value: Optional[pulumi.Input[bool]]): + pulumi.set(self, "send_resolved", value) + + @property + @pulumi.getter + def slug(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "slug") + + @slug.setter + def slug(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "slug", value) + + @property + @pulumi.getter(name="tlsInsecureSkipVerify") + def tls_insecure_skip_verify(self) -> Optional[pulumi.Input[bool]]: + return pulumi.get(self, "tls_insecure_skip_verify") + + @tls_insecure_skip_verify.setter + def tls_insecure_skip_verify(self, value: Optional[pulumi.Input[bool]]): + pulumi.set(self, "tls_insecure_skip_verify", value) + + +@pulumi.input_type +class _WebhookAlertNotifierState: + def __init__(__self__, *, + basic_auth_password: Optional[pulumi.Input[str]] = None, + basic_auth_username: Optional[pulumi.Input[str]] = None, + bearer_token: Optional[pulumi.Input[str]] = None, + name: Optional[pulumi.Input[str]] = None, + proxy_url: Optional[pulumi.Input[str]] = None, + send_resolved: Optional[pulumi.Input[bool]] = None, + slug: Optional[pulumi.Input[str]] = None, + tls_insecure_skip_verify: Optional[pulumi.Input[bool]] = None, + url: Optional[pulumi.Input[str]] = None): + """ + Input properties used for looking up and filtering WebhookAlertNotifier resources. + """ + if basic_auth_password is not None: + pulumi.set(__self__, "basic_auth_password", basic_auth_password) + if basic_auth_username is not None: + pulumi.set(__self__, "basic_auth_username", basic_auth_username) + if bearer_token is not None: + pulumi.set(__self__, "bearer_token", bearer_token) + if name is not None: + pulumi.set(__self__, "name", name) + if proxy_url is not None: + pulumi.set(__self__, "proxy_url", proxy_url) + if send_resolved is not None: + pulumi.set(__self__, "send_resolved", send_resolved) + if slug is not None: + pulumi.set(__self__, "slug", slug) + if tls_insecure_skip_verify is not None: + pulumi.set(__self__, "tls_insecure_skip_verify", tls_insecure_skip_verify) + if url is not None: + pulumi.set(__self__, "url", url) + + @property + @pulumi.getter(name="basicAuthPassword") + def basic_auth_password(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "basic_auth_password") + + @basic_auth_password.setter + def basic_auth_password(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "basic_auth_password", value) + + @property + @pulumi.getter(name="basicAuthUsername") + def basic_auth_username(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "basic_auth_username") + + @basic_auth_username.setter + def basic_auth_username(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "basic_auth_username", value) + + @property + @pulumi.getter(name="bearerToken") + def bearer_token(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "bearer_token") + + @bearer_token.setter + def bearer_token(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "bearer_token", value) + + @property + @pulumi.getter + def name(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "name") + + @name.setter + def name(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "name", value) + + @property + @pulumi.getter(name="proxyUrl") + def proxy_url(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "proxy_url") + + @proxy_url.setter + def proxy_url(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "proxy_url", value) + + @property + @pulumi.getter(name="sendResolved") + def send_resolved(self) -> Optional[pulumi.Input[bool]]: + return pulumi.get(self, "send_resolved") + + @send_resolved.setter + def send_resolved(self, value: Optional[pulumi.Input[bool]]): + pulumi.set(self, "send_resolved", value) + + @property + @pulumi.getter + def slug(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "slug") + + @slug.setter + def slug(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "slug", value) + + @property + @pulumi.getter(name="tlsInsecureSkipVerify") + def tls_insecure_skip_verify(self) -> Optional[pulumi.Input[bool]]: + return pulumi.get(self, "tls_insecure_skip_verify") + + @tls_insecure_skip_verify.setter + def tls_insecure_skip_verify(self, value: Optional[pulumi.Input[bool]]): + pulumi.set(self, "tls_insecure_skip_verify", value) + + @property + @pulumi.getter + def url(self) -> Optional[pulumi.Input[str]]: + return pulumi.get(self, "url") + + @url.setter + def url(self, value: Optional[pulumi.Input[str]]): + pulumi.set(self, "url", value) + + +class WebhookAlertNotifier(pulumi.CustomResource): + @overload + def __init__(__self__, + resource_name: str, + opts: Optional[pulumi.ResourceOptions] = None, + basic_auth_password: Optional[pulumi.Input[str]] = None, + basic_auth_username: Optional[pulumi.Input[str]] = None, + bearer_token: Optional[pulumi.Input[str]] = None, + name: Optional[pulumi.Input[str]] = None, + proxy_url: Optional[pulumi.Input[str]] = None, + send_resolved: Optional[pulumi.Input[bool]] = None, + slug: Optional[pulumi.Input[str]] = None, + tls_insecure_skip_verify: Optional[pulumi.Input[bool]] = None, + url: Optional[pulumi.Input[str]] = None, + __props__=None): + """ + Create a WebhookAlertNotifier resource with the given unique name, props, and options. + :param str resource_name: The name of the resource. + :param pulumi.ResourceOptions opts: Options for the resource. + """ + ... + @overload + def __init__(__self__, + resource_name: str, + args: WebhookAlertNotifierArgs, + opts: Optional[pulumi.ResourceOptions] = None): + """ + Create a WebhookAlertNotifier resource with the given unique name, props, and options. + :param str resource_name: The name of the resource. + :param WebhookAlertNotifierArgs 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(WebhookAlertNotifierArgs, 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_password: Optional[pulumi.Input[str]] = None, + basic_auth_username: Optional[pulumi.Input[str]] = None, + bearer_token: Optional[pulumi.Input[str]] = None, + name: Optional[pulumi.Input[str]] = None, + proxy_url: Optional[pulumi.Input[str]] = None, + send_resolved: Optional[pulumi.Input[bool]] = None, + slug: Optional[pulumi.Input[str]] = None, + tls_insecure_skip_verify: Optional[pulumi.Input[bool]] = None, + url: Optional[pulumi.Input[str]] = None, + __props__=None): + opts = pulumi.ResourceOptions.merge(_utilities.get_resource_opts_defaults(), opts) + if not isinstance(opts, pulumi.ResourceOptions): + raise TypeError('Expected resource options to be a ResourceOptions instance') + if opts.id is None: + if __props__ is not None: + raise TypeError('__props__ is only valid when passed in combination with a valid opts.id to get an existing resource') + __props__ = WebhookAlertNotifierArgs.__new__(WebhookAlertNotifierArgs) + + __props__.__dict__["basic_auth_password"] = None if basic_auth_password is None else pulumi.Output.secret(basic_auth_password) + __props__.__dict__["basic_auth_username"] = basic_auth_username + __props__.__dict__["bearer_token"] = bearer_token + if name is None and not opts.urn: + raise TypeError("Missing required property 'name'") + __props__.__dict__["name"] = name + __props__.__dict__["proxy_url"] = proxy_url + __props__.__dict__["send_resolved"] = send_resolved + __props__.__dict__["slug"] = slug + __props__.__dict__["tls_insecure_skip_verify"] = tls_insecure_skip_verify + if url is None and not opts.urn: + raise TypeError("Missing required property 'url'") + __props__.__dict__["url"] = url + secret_opts = pulumi.ResourceOptions(additional_secret_outputs=["basicAuthPassword"]) + opts = pulumi.ResourceOptions.merge(opts, secret_opts) + super(WebhookAlertNotifier, __self__).__init__( + 'chronosphere:index/webhookAlertNotifier:WebhookAlertNotifier', + resource_name, + __props__, + opts) + + @staticmethod + def get(resource_name: str, + id: pulumi.Input[str], + opts: Optional[pulumi.ResourceOptions] = None, + basic_auth_password: Optional[pulumi.Input[str]] = None, + basic_auth_username: Optional[pulumi.Input[str]] = None, + bearer_token: Optional[pulumi.Input[str]] = None, + name: Optional[pulumi.Input[str]] = None, + proxy_url: Optional[pulumi.Input[str]] = None, + send_resolved: Optional[pulumi.Input[bool]] = None, + slug: Optional[pulumi.Input[str]] = None, + tls_insecure_skip_verify: Optional[pulumi.Input[bool]] = None, + url: Optional[pulumi.Input[str]] = None) -> 'WebhookAlertNotifier': + """ + Get an existing WebhookAlertNotifier 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. + """ + opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id)) + + __props__ = _WebhookAlertNotifierState.__new__(_WebhookAlertNotifierState) + + __props__.__dict__["basic_auth_password"] = basic_auth_password + __props__.__dict__["basic_auth_username"] = basic_auth_username + __props__.__dict__["bearer_token"] = bearer_token + __props__.__dict__["name"] = name + __props__.__dict__["proxy_url"] = proxy_url + __props__.__dict__["send_resolved"] = send_resolved + __props__.__dict__["slug"] = slug + __props__.__dict__["tls_insecure_skip_verify"] = tls_insecure_skip_verify + __props__.__dict__["url"] = url + return WebhookAlertNotifier(resource_name, opts=opts, __props__=__props__) + + @property + @pulumi.getter(name="basicAuthPassword") + def basic_auth_password(self) -> pulumi.Output[Optional[str]]: + return pulumi.get(self, "basic_auth_password") + + @property + @pulumi.getter(name="basicAuthUsername") + def basic_auth_username(self) -> pulumi.Output[Optional[str]]: + return pulumi.get(self, "basic_auth_username") + + @property + @pulumi.getter(name="bearerToken") + def bearer_token(self) -> pulumi.Output[Optional[str]]: + return pulumi.get(self, "bearer_token") + + @property + @pulumi.getter + def name(self) -> pulumi.Output[str]: + return pulumi.get(self, "name") + + @property + @pulumi.getter(name="proxyUrl") + def proxy_url(self) -> pulumi.Output[Optional[str]]: + return pulumi.get(self, "proxy_url") + + @property + @pulumi.getter(name="sendResolved") + def send_resolved(self) -> pulumi.Output[Optional[bool]]: + return pulumi.get(self, "send_resolved") + + @property + @pulumi.getter + def slug(self) -> pulumi.Output[str]: + return pulumi.get(self, "slug") + + @property + @pulumi.getter(name="tlsInsecureSkipVerify") + def tls_insecure_skip_verify(self) -> pulumi.Output[Optional[bool]]: + return pulumi.get(self, "tls_insecure_skip_verify") + + @property + @pulumi.getter + def url(self) -> pulumi.Output[str]: + return pulumi.get(self, "url") + diff --git a/sdk/python/go.mod b/sdk/python/go.mod new file mode 100644 index 00000000..04a6373d --- /dev/null +++ b/sdk/python/go.mod @@ -0,0 +1,3 @@ +module fake_python_module // Exclude this directory from Go tools + +go 1.21 diff --git a/sdk/python/setup.py b/sdk/python/setup.py new file mode 100644 index 00000000..76357278 --- /dev/null +++ b/sdk/python/setup.py @@ -0,0 +1,44 @@ +# coding=utf-8 +# *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +# *** Do not edit by hand unless you're certain you know what you are doing! *** + +import 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 "chronosphere Pulumi Package - Development Version" + + +setup(name='chronosphereio_chronosphere', + python_requires='>=3.7', + version=VERSION, + description="Chronosphere Pulumi Provider", + long_description=readme(), + long_description_content_type='text/markdown', + keywords='chronosphere observability prometheus', + url='https://chronosphere.io', + project_urls={ + 'Repository': 'https://github.com/chronosphereio/pulumi-chronosphere' + }, + license='Apache-2.0', + packages=find_packages(), + package_data={ + 'chronosphereio_chronosphere': [ + 'py.typed', + 'pulumi-plugin.json', + ] + }, + install_requires=[ + 'parver>=0.2.1', + 'pulumi>=3.0.0,<4.0.0', + 'semver>=2.8.1' + ], + zip_safe=False)