diff --git a/provider/cmd/pulumi-resource-dynatrace/schema.json b/provider/cmd/pulumi-resource-dynatrace/schema.json index c665ee8e..08a09584 100644 --- a/provider/cmd/pulumi-resource-dynatrace/schema.json +++ b/provider/cmd/pulumi-resource-dynatrace/schema.json @@ -42916,6 +42916,38 @@ } } }, + "dynatrace:index/getApplicationDetectionRulesValue:getApplicationDetectionRulesValue": { + "properties": { + "applicationId": { + "type": "string", + "description": "Application ID\n" + }, + "id": { + "type": "string", + "description": "Application Detection Rule ID\n" + }, + "matcher": { + "type": "string", + "description": "Matcher\n" + }, + "pattern": { + "type": "string", + "description": "Pattern\n" + } + }, + "type": "object", + "required": [ + "applicationId", + "id", + "matcher", + "pattern" + ], + "language": { + "nodejs": { + "requiredInputs": [] + } + } + }, "dynatrace:index/getDocumentsValue:getDocumentsValue": { "properties": { "id": { @@ -59511,7 +59543,7 @@ "properties": { "contents": { "type": "string", - "description": "This attribute exists for backwards compatibility. You do not have to define it.\n" + "description": "Contains the JSON Code of the Dashboard\n" } }, "required": [ @@ -59520,15 +59552,18 @@ "inputProperties": { "contents": { "type": "string", - "description": "This attribute exists for backwards compatibility. You do not have to define it.\n" + "description": "Contains the JSON Code of the Dashboard\n" } }, + "requiredInputs": [ + "contents" + ], "stateInputs": { "description": "Input properties used for looking up and filtering JsonDashboardBase resources.\n", "properties": { "contents": { "type": "string", - "description": "This attribute exists for backwards compatibility. You do not have to define it.\n" + "description": "Contains the JSON Code of the Dashboard\n" } }, "type": "object" @@ -75874,6 +75909,29 @@ ] } }, + "dynatrace:index/getApplicationDetectionRules:getApplicationDetectionRules": { + "description": "The application detection rules data source allows retrieval of all existing rules.\n\n## Example Usage\n\n\u003c!--Start PulumiCodeChooser --\u003e\n```typescript\nimport * as pulumi from \"@pulumi/pulumi\";\nimport * as dynatrace from \"@pulumi/dynatrace\";\n\nconst test = dynatrace.getApplicationDetectionRules({});\nexport const applicationDetectionRules = test;\n```\n```python\nimport pulumi\nimport pulumi_dynatrace as dynatrace\n\ntest = dynatrace.get_application_detection_rules()\npulumi.export(\"applicationDetectionRules\", test)\n```\n```csharp\nusing System.Collections.Generic;\nusing System.Linq;\nusing Pulumi;\nusing Dynatrace = Pulumi.Dynatrace;\n\nreturn await Deployment.RunAsync(() =\u003e \n{\n var test = Dynatrace.GetApplicationDetectionRules.Invoke();\n\n return new Dictionary\u003cstring, object?\u003e\n {\n [\"applicationDetectionRules\"] = test,\n };\n});\n```\n```go\npackage main\n\nimport (\n\t\"github.com/pulumi/pulumi/sdk/v3/go/pulumi\"\n\t\"github.com/pulumiverse/pulumi-dynatrace/sdk/go/dynatrace\"\n)\n\nfunc main() {\n\tpulumi.Run(func(ctx *pulumi.Context) error {\n\t\ttest, err := dynatrace.GetApplicationDetectionRules(ctx, map[string]interface{}{}, nil)\n\t\tif err != nil {\n\t\t\treturn err\n\t\t}\n\t\tctx.Export(\"applicationDetectionRules\", test)\n\t\treturn nil\n\t})\n}\n```\n```java\npackage generated_program;\n\nimport com.pulumi.Context;\nimport com.pulumi.Pulumi;\nimport com.pulumi.core.Output;\nimport com.pulumi.dynatrace.DynatraceFunctions;\nimport java.util.List;\nimport java.util.ArrayList;\nimport java.util.Map;\nimport java.io.File;\nimport java.nio.file.Files;\nimport java.nio.file.Paths;\n\npublic class App {\n public static void main(String[] args) {\n Pulumi.run(App::stack);\n }\n\n public static void stack(Context ctx) {\n final var test = DynatraceFunctions.getApplicationDetectionRules();\n\n ctx.export(\"applicationDetectionRules\", test.applyValue(getApplicationDetectionRulesResult -\u003e getApplicationDetectionRulesResult));\n }\n}\n```\n```yaml\nvariables:\n test:\n fn::invoke:\n function: dynatrace:getApplicationDetectionRules\n arguments: {}\noutputs:\n applicationDetectionRules: ${test}\n```\n\u003c!--End PulumiCodeChooser --\u003e\n", + "outputs": { + "description": "A collection of values returned by getApplicationDetectionRules.\n", + "properties": { + "id": { + "type": "string", + "description": "The provider-assigned unique ID for this managed resource.\n" + }, + "values": { + "type": "array", + "items": { + "$ref": "#/types/dynatrace:index/getApplicationDetectionRulesValue:getApplicationDetectionRulesValue" + } + } + }, + "type": "object", + "required": [ + "values", + "id" + ] + } + }, "dynatrace:index/getAttackAlerting:getAttackAlerting": { "description": "The `dynatrace.AttackAlerting` data source allows the attack alerting profile ID to be retrieved by its name.\n\n- `name` (String) - The name of the attack alerting profile\n\nIf multiple services match the given criteria, the first result will be retrieved.\n\n## Example Usage\n\n\u003c!--Start PulumiCodeChooser --\u003e\n```typescript\nimport * as pulumi from \"@pulumi/pulumi\";\nimport * as dynatrace from \"@pulumi/dynatrace\";\n\nconst example = dynatrace.getAttackAlerting({\n name: \"Terraform Example\",\n});\nexport const id = example.then(example =\u003e example.id);\n```\n```python\nimport pulumi\nimport pulumi_dynatrace as dynatrace\n\nexample = dynatrace.get_attack_alerting(name=\"Terraform Example\")\npulumi.export(\"id\", example.id)\n```\n```csharp\nusing System.Collections.Generic;\nusing System.Linq;\nusing Pulumi;\nusing Dynatrace = Pulumi.Dynatrace;\n\nreturn await Deployment.RunAsync(() =\u003e \n{\n var example = Dynatrace.GetAttackAlerting.Invoke(new()\n {\n Name = \"Terraform Example\",\n });\n\n return new Dictionary\u003cstring, object?\u003e\n {\n [\"id\"] = example.Apply(getAttackAlertingResult =\u003e getAttackAlertingResult.Id),\n };\n});\n```\n```go\npackage main\n\nimport (\n\t\"github.com/pulumi/pulumi/sdk/v3/go/pulumi\"\n\t\"github.com/pulumiverse/pulumi-dynatrace/sdk/go/dynatrace\"\n)\n\nfunc main() {\n\tpulumi.Run(func(ctx *pulumi.Context) error {\n\t\texample, err := dynatrace.LookupAttackAlerting(ctx, \u0026dynatrace.LookupAttackAlertingArgs{\n\t\t\tName: \"Terraform Example\",\n\t\t}, nil)\n\t\tif err != nil {\n\t\t\treturn err\n\t\t}\n\t\tctx.Export(\"id\", example.Id)\n\t\treturn nil\n\t})\n}\n```\n```java\npackage generated_program;\n\nimport com.pulumi.Context;\nimport com.pulumi.Pulumi;\nimport com.pulumi.core.Output;\nimport com.pulumi.dynatrace.DynatraceFunctions;\nimport com.pulumi.dynatrace.inputs.GetAttackAlertingArgs;\nimport java.util.List;\nimport java.util.ArrayList;\nimport java.util.Map;\nimport java.io.File;\nimport java.nio.file.Files;\nimport java.nio.file.Paths;\n\npublic class App {\n public static void main(String[] args) {\n Pulumi.run(App::stack);\n }\n\n public static void stack(Context ctx) {\n final var example = DynatraceFunctions.getAttackAlerting(GetAttackAlertingArgs.builder()\n .name(\"Terraform Example\")\n .build());\n\n ctx.export(\"id\", example.applyValue(getAttackAlertingResult -\u003e getAttackAlertingResult.id()));\n }\n}\n```\n```yaml\nvariables:\n example:\n fn::invoke:\n function: dynatrace:getAttackAlerting\n arguments:\n name: Terraform Example\noutputs:\n id: ${example.id}\n```\n\u003c!--End PulumiCodeChooser --\u003e\n", "inputs": { diff --git a/provider/go.mod b/provider/go.mod index 3e72dd15..e795ae9b 100644 --- a/provider/go.mod +++ b/provider/go.mod @@ -7,8 +7,8 @@ toolchain go1.23.2 replace github.com/hashicorp/terraform-plugin-sdk/v2 => github.com/pulumi/terraform-plugin-sdk/v2 v2.0.0-20240520223432-0c0bf0d65f10 require ( - github.com/dynatrace-oss/terraform-provider-dynatrace v1.72.2 - github.com/pulumi/pulumi-terraform-bridge/v3 v3.100.0 + github.com/dynatrace-oss/terraform-provider-dynatrace v1.72.3 + github.com/pulumi/pulumi-terraform-bridge/v3 v3.101.0 github.com/pulumi/pulumi/sdk/v3 v3.145.0 ) diff --git a/provider/go.sum b/provider/go.sum index f388c9c7..fd4382a3 100644 --- a/provider/go.sum +++ b/provider/go.sum @@ -1337,8 +1337,8 @@ github.com/dlclark/regexp2 v1.11.4/go.mod h1:DHkYz0B9wPfa6wondMfaivmHpzrQ3v9q8cn github.com/docopt/docopt-go v0.0.0-20180111231733-ee0de3bc6815/go.mod h1:WwZ+bS3ebgob9U8Nd0kOddGdZWjyMGR8Wziv+TBNwSE= github.com/dustin/go-humanize v1.0.0/go.mod h1:HtrtbFcZ19U5GC7JDqmcUSB87Iq5E25KnS6fMYU6eOk= github.com/dustin/go-humanize v1.0.1/go.mod h1:Mu1zIs6XwVuF/gI1OepvI0qD18qycQx+mFykh5fBlto= -github.com/dynatrace-oss/terraform-provider-dynatrace v1.72.2 h1:ei7GsgwRagTPtVfD8vOtIHgp8x9f4gkTwXgODzDX15w= -github.com/dynatrace-oss/terraform-provider-dynatrace v1.72.2/go.mod h1:QCafDZ6KR6X6fS2bjPX3vK43M7SU/WLy5RD0Z7nHbmk= +github.com/dynatrace-oss/terraform-provider-dynatrace v1.72.3 h1:Z8QxuU0Ay/bG3s/gJ+n+IC5SBuPTbndpqXwV9OuN5g4= +github.com/dynatrace-oss/terraform-provider-dynatrace v1.72.3/go.mod h1:QCafDZ6KR6X6fS2bjPX3vK43M7SU/WLy5RD0Z7nHbmk= github.com/dynatrace/dynatrace-configuration-as-code-core v0.7.1-0.20241203095532-6211d1be0eb7 h1:OYTSC/vJETxZHWZEaZsmxH26xIThpDQ9es8rHA6cI9o= github.com/dynatrace/dynatrace-configuration-as-code-core v0.7.1-0.20241203095532-6211d1be0eb7/go.mod h1:uexblPw82NA/x+hnBOMhHdc3xlM9tuUPW4+sVcd80Ow= github.com/edsrzf/mmap-go v1.1.0 h1:6EUwBLQ/Mcr1EYLE4Tn1VdW1A4ckqCQWZBw8Hr0kjpQ= @@ -1941,8 +1941,8 @@ github.com/pulumi/providertest v0.1.3 h1:GpNKRy/haNjRHiUA9bi4diU4Op2zf3axYXbga5A github.com/pulumi/providertest v0.1.3/go.mod h1:GcsqEGgSngwaNOD+kICJPIUQlnA911fGBU8HDlJvVL0= github.com/pulumi/pulumi-java/pkg v0.19.0 h1:T9kkGUQJV7UTxenw08m3txsgQkNVnZZxvn1zCcNjaE8= github.com/pulumi/pulumi-java/pkg v0.19.0/go.mod h1:YKYYFEb3Jvzf/dDJo0xOeEkIfBAMkkkdhXulauvEjmc= -github.com/pulumi/pulumi-terraform-bridge/v3 v3.100.0 h1:L03nXHLprXuF0wIihoKFIjpE8oSPomiMayrRVDv1VgY= -github.com/pulumi/pulumi-terraform-bridge/v3 v3.100.0/go.mod h1:r+cxSrRxwCRbHMdKMKWU3NKDcUTm9xa9PcBDuHQnRkI= +github.com/pulumi/pulumi-terraform-bridge/v3 v3.101.0 h1:LucjkMkSU2iMuMdLYhRaVDiCYbJ1Fqve/sMw+iffjEY= +github.com/pulumi/pulumi-terraform-bridge/v3 v3.101.0/go.mod h1:r+cxSrRxwCRbHMdKMKWU3NKDcUTm9xa9PcBDuHQnRkI= github.com/pulumi/pulumi-yaml v1.12.0 h1:ThJP+EBqeJyCnS6w6/PwcEFOT5o112qv0lObhefmFCk= github.com/pulumi/pulumi-yaml v1.12.0/go.mod h1:EhZd1XDfuLa15O51qVVE16U6r8ldK9mLIBclqWCX27Y= github.com/pulumi/pulumi/pkg/v3 v3.145.0 h1:hAhFLieunnCKuMd3GbLqE5uWQ1hpNLdl6+bCDFSF4YQ= diff --git a/sdk/dotnet/GetApplicationDetectionRules.cs b/sdk/dotnet/GetApplicationDetectionRules.cs new file mode 100644 index 00000000..c9bb88e4 --- /dev/null +++ b/sdk/dotnet/GetApplicationDetectionRules.cs @@ -0,0 +1,111 @@ +// *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Threading.Tasks; +using Pulumi.Serialization; +using Pulumi; + +namespace Pulumiverse.Dynatrace +{ + public static class GetApplicationDetectionRules + { + /// + /// The application detection rules data source allows retrieval of all existing rules. + /// + /// ## Example Usage + /// + /// ```csharp + /// using System.Collections.Generic; + /// using System.Linq; + /// using Pulumi; + /// using Dynatrace = Pulumi.Dynatrace; + /// + /// return await Deployment.RunAsync(() => + /// { + /// var test = Dynatrace.GetApplicationDetectionRules.Invoke(); + /// + /// return new Dictionary<string, object?> + /// { + /// ["applicationDetectionRules"] = test, + /// }; + /// }); + /// ``` + /// + public static Task InvokeAsync(InvokeOptions? options = null) + => global::Pulumi.Deployment.Instance.InvokeAsync("dynatrace:index/getApplicationDetectionRules:getApplicationDetectionRules", InvokeArgs.Empty, options.WithDefaults()); + + /// + /// The application detection rules data source allows retrieval of all existing rules. + /// + /// ## Example Usage + /// + /// ```csharp + /// using System.Collections.Generic; + /// using System.Linq; + /// using Pulumi; + /// using Dynatrace = Pulumi.Dynatrace; + /// + /// return await Deployment.RunAsync(() => + /// { + /// var test = Dynatrace.GetApplicationDetectionRules.Invoke(); + /// + /// return new Dictionary<string, object?> + /// { + /// ["applicationDetectionRules"] = test, + /// }; + /// }); + /// ``` + /// + public static Output Invoke(InvokeOptions? options = null) + => global::Pulumi.Deployment.Instance.Invoke("dynatrace:index/getApplicationDetectionRules:getApplicationDetectionRules", InvokeArgs.Empty, options.WithDefaults()); + + /// + /// The application detection rules data source allows retrieval of all existing rules. + /// + /// ## Example Usage + /// + /// ```csharp + /// using System.Collections.Generic; + /// using System.Linq; + /// using Pulumi; + /// using Dynatrace = Pulumi.Dynatrace; + /// + /// return await Deployment.RunAsync(() => + /// { + /// var test = Dynatrace.GetApplicationDetectionRules.Invoke(); + /// + /// return new Dictionary<string, object?> + /// { + /// ["applicationDetectionRules"] = test, + /// }; + /// }); + /// ``` + /// + public static Output Invoke(InvokeOutputOptions options) + => global::Pulumi.Deployment.Instance.Invoke("dynatrace:index/getApplicationDetectionRules:getApplicationDetectionRules", InvokeArgs.Empty, options.WithDefaults()); + } + + + [OutputType] + public sealed class GetApplicationDetectionRulesResult + { + /// + /// The provider-assigned unique ID for this managed resource. + /// + public readonly string Id; + public readonly ImmutableArray Values; + + [OutputConstructor] + private GetApplicationDetectionRulesResult( + string id, + + ImmutableArray values) + { + Id = id; + Values = values; + } + } +} diff --git a/sdk/dotnet/JsonDashboardBase.cs b/sdk/dotnet/JsonDashboardBase.cs index 32a0cbac..efaa15c0 100644 --- a/sdk/dotnet/JsonDashboardBase.cs +++ b/sdk/dotnet/JsonDashboardBase.cs @@ -14,7 +14,7 @@ namespace Pulumiverse.Dynatrace public partial class JsonDashboardBase : global::Pulumi.CustomResource { /// - /// This attribute exists for backwards compatibility. You do not have to define it. + /// Contains the JSON Code of the Dashboard /// [Output("contents")] public Output Contents { get; private set; } = null!; @@ -27,7 +27,7 @@ public partial class JsonDashboardBase : global::Pulumi.CustomResource /// The unique name of the resource /// The arguments used to populate this resource's properties /// A bag of options that control this resource's behavior - public JsonDashboardBase(string name, JsonDashboardBaseArgs? args = null, CustomResourceOptions? options = null) + public JsonDashboardBase(string name, JsonDashboardBaseArgs args, CustomResourceOptions? options = null) : base("dynatrace:index/jsonDashboardBase:JsonDashboardBase", name, args ?? new JsonDashboardBaseArgs(), MakeResourceOptions(options, "")) { } @@ -67,10 +67,10 @@ public static JsonDashboardBase Get(string name, Input id, JsonDashboard public sealed class JsonDashboardBaseArgs : global::Pulumi.ResourceArgs { /// - /// This attribute exists for backwards compatibility. You do not have to define it. + /// Contains the JSON Code of the Dashboard /// - [Input("contents")] - public Input? Contents { get; set; } + [Input("contents", required: true)] + public Input Contents { get; set; } = null!; public JsonDashboardBaseArgs() { @@ -81,7 +81,7 @@ public JsonDashboardBaseArgs() public sealed class JsonDashboardBaseState : global::Pulumi.ResourceArgs { /// - /// This attribute exists for backwards compatibility. You do not have to define it. + /// Contains the JSON Code of the Dashboard /// [Input("contents")] public Input? Contents { get; set; } diff --git a/sdk/dotnet/Outputs/GetApplicationDetectionRulesValueResult.cs b/sdk/dotnet/Outputs/GetApplicationDetectionRulesValueResult.cs new file mode 100644 index 00000000..28c5a175 --- /dev/null +++ b/sdk/dotnet/Outputs/GetApplicationDetectionRulesValueResult.cs @@ -0,0 +1,50 @@ +// *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +using System; +using System.Collections.Generic; +using System.Collections.Immutable; +using System.Threading.Tasks; +using Pulumi.Serialization; +using Pulumi; + +namespace Pulumiverse.Dynatrace.Outputs +{ + + [OutputType] + public sealed class GetApplicationDetectionRulesValueResult + { + /// + /// Application ID + /// + public readonly string ApplicationId; + /// + /// Application Detection Rule ID + /// + public readonly string Id; + /// + /// Matcher + /// + public readonly string Matcher; + /// + /// Pattern + /// + public readonly string Pattern; + + [OutputConstructor] + private GetApplicationDetectionRulesValueResult( + string applicationId, + + string id, + + string matcher, + + string pattern) + { + ApplicationId = applicationId; + Id = id; + Matcher = matcher; + Pattern = pattern; + } + } +} diff --git a/sdk/go/dynatrace/getApplicationDetectionRules.go b/sdk/go/dynatrace/getApplicationDetectionRules.go new file mode 100644 index 00000000..9f2dce8c --- /dev/null +++ b/sdk/go/dynatrace/getApplicationDetectionRules.go @@ -0,0 +1,90 @@ +// Code generated by the Pulumi Terraform Bridge (tfgen) Tool DO NOT EDIT. +// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! *** + +package dynatrace + +import ( + "context" + "reflect" + + "github.com/pulumi/pulumi/sdk/v3/go/pulumi" + "github.com/pulumiverse/pulumi-dynatrace/sdk/go/dynatrace/internal" +) + +// The application detection rules data source allows retrieval of all existing rules. +// +// ## Example Usage +// +// ```go +// package main +// +// import ( +// +// "github.com/pulumi/pulumi/sdk/v3/go/pulumi" +// "github.com/pulumiverse/pulumi-dynatrace/sdk/go/dynatrace" +// +// ) +// +// func main() { +// pulumi.Run(func(ctx *pulumi.Context) error { +// test, err := dynatrace.GetApplicationDetectionRules(ctx, map[string]interface{}{}, nil) +// if err != nil { +// return err +// } +// ctx.Export("applicationDetectionRules", test) +// return nil +// }) +// } +// +// ``` +func GetApplicationDetectionRules(ctx *pulumi.Context, opts ...pulumi.InvokeOption) (*GetApplicationDetectionRulesResult, error) { + opts = internal.PkgInvokeDefaultOpts(opts) + var rv GetApplicationDetectionRulesResult + err := ctx.Invoke("dynatrace:index/getApplicationDetectionRules:getApplicationDetectionRules", nil, &rv, opts...) + if err != nil { + return nil, err + } + return &rv, nil +} + +// A collection of values returned by getApplicationDetectionRules. +type GetApplicationDetectionRulesResult struct { + // The provider-assigned unique ID for this managed resource. + Id string `pulumi:"id"` + Values []GetApplicationDetectionRulesValue `pulumi:"values"` +} + +func GetApplicationDetectionRulesOutput(ctx *pulumi.Context, opts ...pulumi.InvokeOption) GetApplicationDetectionRulesResultOutput { + return pulumi.ToOutput(0).ApplyT(func(int) (GetApplicationDetectionRulesResultOutput, error) { + options := pulumi.InvokeOutputOptions{InvokeOptions: internal.PkgInvokeDefaultOpts(opts)} + return ctx.InvokeOutput("dynatrace:index/getApplicationDetectionRules:getApplicationDetectionRules", nil, GetApplicationDetectionRulesResultOutput{}, options).(GetApplicationDetectionRulesResultOutput), nil + }).(GetApplicationDetectionRulesResultOutput) +} + +// A collection of values returned by getApplicationDetectionRules. +type GetApplicationDetectionRulesResultOutput struct{ *pulumi.OutputState } + +func (GetApplicationDetectionRulesResultOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetApplicationDetectionRulesResult)(nil)).Elem() +} + +func (o GetApplicationDetectionRulesResultOutput) ToGetApplicationDetectionRulesResultOutput() GetApplicationDetectionRulesResultOutput { + return o +} + +func (o GetApplicationDetectionRulesResultOutput) ToGetApplicationDetectionRulesResultOutputWithContext(ctx context.Context) GetApplicationDetectionRulesResultOutput { + return o +} + +// The provider-assigned unique ID for this managed resource. +func (o GetApplicationDetectionRulesResultOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v GetApplicationDetectionRulesResult) string { return v.Id }).(pulumi.StringOutput) +} + +func (o GetApplicationDetectionRulesResultOutput) Values() GetApplicationDetectionRulesValueArrayOutput { + return o.ApplyT(func(v GetApplicationDetectionRulesResult) []GetApplicationDetectionRulesValue { return v.Values }).(GetApplicationDetectionRulesValueArrayOutput) +} + +func init() { + pulumi.RegisterOutputType(GetApplicationDetectionRulesResultOutput{}) +} diff --git a/sdk/go/dynatrace/jsonDashboardBase.go b/sdk/go/dynatrace/jsonDashboardBase.go index 05489cc3..fba31c8e 100644 --- a/sdk/go/dynatrace/jsonDashboardBase.go +++ b/sdk/go/dynatrace/jsonDashboardBase.go @@ -7,6 +7,7 @@ import ( "context" "reflect" + "errors" "github.com/pulumi/pulumi/sdk/v3/go/pulumi" "github.com/pulumiverse/pulumi-dynatrace/sdk/go/dynatrace/internal" ) @@ -14,7 +15,7 @@ import ( type JsonDashboardBase struct { pulumi.CustomResourceState - // This attribute exists for backwards compatibility. You do not have to define it. + // Contains the JSON Code of the Dashboard Contents pulumi.StringOutput `pulumi:"contents"` } @@ -22,9 +23,12 @@ type JsonDashboardBase struct { func NewJsonDashboardBase(ctx *pulumi.Context, name string, args *JsonDashboardBaseArgs, opts ...pulumi.ResourceOption) (*JsonDashboardBase, error) { if args == nil { - args = &JsonDashboardBaseArgs{} + return nil, errors.New("missing one or more required arguments") } + if args.Contents == nil { + return nil, errors.New("invalid value for required argument 'Contents'") + } opts = internal.PkgResourceDefaultOpts(opts) var resource JsonDashboardBase err := ctx.RegisterResource("dynatrace:index/jsonDashboardBase:JsonDashboardBase", name, args, &resource, opts...) @@ -48,12 +52,12 @@ func GetJsonDashboardBase(ctx *pulumi.Context, // Input properties used for looking up and filtering JsonDashboardBase resources. type jsonDashboardBaseState struct { - // This attribute exists for backwards compatibility. You do not have to define it. + // Contains the JSON Code of the Dashboard Contents *string `pulumi:"contents"` } type JsonDashboardBaseState struct { - // This attribute exists for backwards compatibility. You do not have to define it. + // Contains the JSON Code of the Dashboard Contents pulumi.StringPtrInput } @@ -62,14 +66,14 @@ func (JsonDashboardBaseState) ElementType() reflect.Type { } type jsonDashboardBaseArgs struct { - // This attribute exists for backwards compatibility. You do not have to define it. - Contents *string `pulumi:"contents"` + // Contains the JSON Code of the Dashboard + Contents string `pulumi:"contents"` } // The set of arguments for constructing a JsonDashboardBase resource. type JsonDashboardBaseArgs struct { - // This attribute exists for backwards compatibility. You do not have to define it. - Contents pulumi.StringPtrInput + // Contains the JSON Code of the Dashboard + Contents pulumi.StringInput } func (JsonDashboardBaseArgs) ElementType() reflect.Type { @@ -159,7 +163,7 @@ func (o JsonDashboardBaseOutput) ToJsonDashboardBaseOutputWithContext(ctx contex return o } -// This attribute exists for backwards compatibility. You do not have to define it. +// Contains the JSON Code of the Dashboard func (o JsonDashboardBaseOutput) Contents() pulumi.StringOutput { return o.ApplyT(func(v *JsonDashboardBase) pulumi.StringOutput { return v.Contents }).(pulumi.StringOutput) } diff --git a/sdk/go/dynatrace/pulumiTypes3.go b/sdk/go/dynatrace/pulumiTypes3.go index 759e42fb..90e75d21 100644 --- a/sdk/go/dynatrace/pulumiTypes3.go +++ b/sdk/go/dynatrace/pulumiTypes3.go @@ -45762,6 +45762,130 @@ func (o GetApiTokensApiTokenArrayOutput) Index(i pulumi.IntInput) GetApiTokensAp }).(GetApiTokensApiTokenOutput) } +type GetApplicationDetectionRulesValue struct { + // Application ID + ApplicationId string `pulumi:"applicationId"` + // Application Detection Rule ID + Id string `pulumi:"id"` + // Matcher + Matcher string `pulumi:"matcher"` + // Pattern + Pattern string `pulumi:"pattern"` +} + +// GetApplicationDetectionRulesValueInput is an input type that accepts GetApplicationDetectionRulesValueArgs and GetApplicationDetectionRulesValueOutput values. +// You can construct a concrete instance of `GetApplicationDetectionRulesValueInput` via: +// +// GetApplicationDetectionRulesValueArgs{...} +type GetApplicationDetectionRulesValueInput interface { + pulumi.Input + + ToGetApplicationDetectionRulesValueOutput() GetApplicationDetectionRulesValueOutput + ToGetApplicationDetectionRulesValueOutputWithContext(context.Context) GetApplicationDetectionRulesValueOutput +} + +type GetApplicationDetectionRulesValueArgs struct { + // Application ID + ApplicationId pulumi.StringInput `pulumi:"applicationId"` + // Application Detection Rule ID + Id pulumi.StringInput `pulumi:"id"` + // Matcher + Matcher pulumi.StringInput `pulumi:"matcher"` + // Pattern + Pattern pulumi.StringInput `pulumi:"pattern"` +} + +func (GetApplicationDetectionRulesValueArgs) ElementType() reflect.Type { + return reflect.TypeOf((*GetApplicationDetectionRulesValue)(nil)).Elem() +} + +func (i GetApplicationDetectionRulesValueArgs) ToGetApplicationDetectionRulesValueOutput() GetApplicationDetectionRulesValueOutput { + return i.ToGetApplicationDetectionRulesValueOutputWithContext(context.Background()) +} + +func (i GetApplicationDetectionRulesValueArgs) ToGetApplicationDetectionRulesValueOutputWithContext(ctx context.Context) GetApplicationDetectionRulesValueOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetApplicationDetectionRulesValueOutput) +} + +// GetApplicationDetectionRulesValueArrayInput is an input type that accepts GetApplicationDetectionRulesValueArray and GetApplicationDetectionRulesValueArrayOutput values. +// You can construct a concrete instance of `GetApplicationDetectionRulesValueArrayInput` via: +// +// GetApplicationDetectionRulesValueArray{ GetApplicationDetectionRulesValueArgs{...} } +type GetApplicationDetectionRulesValueArrayInput interface { + pulumi.Input + + ToGetApplicationDetectionRulesValueArrayOutput() GetApplicationDetectionRulesValueArrayOutput + ToGetApplicationDetectionRulesValueArrayOutputWithContext(context.Context) GetApplicationDetectionRulesValueArrayOutput +} + +type GetApplicationDetectionRulesValueArray []GetApplicationDetectionRulesValueInput + +func (GetApplicationDetectionRulesValueArray) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetApplicationDetectionRulesValue)(nil)).Elem() +} + +func (i GetApplicationDetectionRulesValueArray) ToGetApplicationDetectionRulesValueArrayOutput() GetApplicationDetectionRulesValueArrayOutput { + return i.ToGetApplicationDetectionRulesValueArrayOutputWithContext(context.Background()) +} + +func (i GetApplicationDetectionRulesValueArray) ToGetApplicationDetectionRulesValueArrayOutputWithContext(ctx context.Context) GetApplicationDetectionRulesValueArrayOutput { + return pulumi.ToOutputWithContext(ctx, i).(GetApplicationDetectionRulesValueArrayOutput) +} + +type GetApplicationDetectionRulesValueOutput struct{ *pulumi.OutputState } + +func (GetApplicationDetectionRulesValueOutput) ElementType() reflect.Type { + return reflect.TypeOf((*GetApplicationDetectionRulesValue)(nil)).Elem() +} + +func (o GetApplicationDetectionRulesValueOutput) ToGetApplicationDetectionRulesValueOutput() GetApplicationDetectionRulesValueOutput { + return o +} + +func (o GetApplicationDetectionRulesValueOutput) ToGetApplicationDetectionRulesValueOutputWithContext(ctx context.Context) GetApplicationDetectionRulesValueOutput { + return o +} + +// Application ID +func (o GetApplicationDetectionRulesValueOutput) ApplicationId() pulumi.StringOutput { + return o.ApplyT(func(v GetApplicationDetectionRulesValue) string { return v.ApplicationId }).(pulumi.StringOutput) +} + +// Application Detection Rule ID +func (o GetApplicationDetectionRulesValueOutput) Id() pulumi.StringOutput { + return o.ApplyT(func(v GetApplicationDetectionRulesValue) string { return v.Id }).(pulumi.StringOutput) +} + +// Matcher +func (o GetApplicationDetectionRulesValueOutput) Matcher() pulumi.StringOutput { + return o.ApplyT(func(v GetApplicationDetectionRulesValue) string { return v.Matcher }).(pulumi.StringOutput) +} + +// Pattern +func (o GetApplicationDetectionRulesValueOutput) Pattern() pulumi.StringOutput { + return o.ApplyT(func(v GetApplicationDetectionRulesValue) string { return v.Pattern }).(pulumi.StringOutput) +} + +type GetApplicationDetectionRulesValueArrayOutput struct{ *pulumi.OutputState } + +func (GetApplicationDetectionRulesValueArrayOutput) ElementType() reflect.Type { + return reflect.TypeOf((*[]GetApplicationDetectionRulesValue)(nil)).Elem() +} + +func (o GetApplicationDetectionRulesValueArrayOutput) ToGetApplicationDetectionRulesValueArrayOutput() GetApplicationDetectionRulesValueArrayOutput { + return o +} + +func (o GetApplicationDetectionRulesValueArrayOutput) ToGetApplicationDetectionRulesValueArrayOutputWithContext(ctx context.Context) GetApplicationDetectionRulesValueArrayOutput { + return o +} + +func (o GetApplicationDetectionRulesValueArrayOutput) Index(i pulumi.IntInput) GetApplicationDetectionRulesValueOutput { + return pulumi.All(o, i).ApplyT(func(vs []interface{}) GetApplicationDetectionRulesValue { + return vs[0].([]GetApplicationDetectionRulesValue)[vs[1].(int)] + }).(GetApplicationDetectionRulesValueOutput) +} + type GetDocumentsValue struct { // The unique identifier of the document. Id string `pulumi:"id"` @@ -48329,6 +48453,8 @@ func init() { pulumi.RegisterInputType(reflect.TypeOf((*GetAlertingProfilesValueArrayInput)(nil)).Elem(), GetAlertingProfilesValueArray{}) pulumi.RegisterInputType(reflect.TypeOf((*GetApiTokensApiTokenInput)(nil)).Elem(), GetApiTokensApiTokenArgs{}) pulumi.RegisterInputType(reflect.TypeOf((*GetApiTokensApiTokenArrayInput)(nil)).Elem(), GetApiTokensApiTokenArray{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetApplicationDetectionRulesValueInput)(nil)).Elem(), GetApplicationDetectionRulesValueArgs{}) + pulumi.RegisterInputType(reflect.TypeOf((*GetApplicationDetectionRulesValueArrayInput)(nil)).Elem(), GetApplicationDetectionRulesValueArray{}) pulumi.RegisterInputType(reflect.TypeOf((*GetDocumentsValueInput)(nil)).Elem(), GetDocumentsValueArgs{}) pulumi.RegisterInputType(reflect.TypeOf((*GetDocumentsValueArrayInput)(nil)).Elem(), GetDocumentsValueArray{}) pulumi.RegisterInputType(reflect.TypeOf((*GetEntitiesEntityInput)(nil)).Elem(), GetEntitiesEntityArgs{}) @@ -48928,6 +49054,8 @@ func init() { pulumi.RegisterOutputType(GetAlertingProfilesValueArrayOutput{}) pulumi.RegisterOutputType(GetApiTokensApiTokenOutput{}) pulumi.RegisterOutputType(GetApiTokensApiTokenArrayOutput{}) + pulumi.RegisterOutputType(GetApplicationDetectionRulesValueOutput{}) + pulumi.RegisterOutputType(GetApplicationDetectionRulesValueArrayOutput{}) pulumi.RegisterOutputType(GetDocumentsValueOutput{}) pulumi.RegisterOutputType(GetDocumentsValueArrayOutput{}) pulumi.RegisterOutputType(GetEntitiesEntityOutput{}) diff --git a/sdk/nodejs/getApplicationDetectionRules.ts b/sdk/nodejs/getApplicationDetectionRules.ts new file mode 100644 index 00000000..a31568ad --- /dev/null +++ b/sdk/nodejs/getApplicationDetectionRules.ts @@ -0,0 +1,55 @@ +// *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. *** +// *** Do not edit by hand unless you're certain you know what you are doing! *** + +import * as pulumi from "@pulumi/pulumi"; +import * as inputs from "./types/input"; +import * as outputs from "./types/output"; +import * as utilities from "./utilities"; + +/** + * The application detection rules data source allows retrieval of all existing rules. + * + * ## Example Usage + * + * ```typescript + * import * as pulumi from "@pulumi/pulumi"; + * import * as dynatrace from "@pulumi/dynatrace"; + * + * const test = dynatrace.getApplicationDetectionRules({}); + * export const applicationDetectionRules = test; + * ``` + */ +export function getApplicationDetectionRules(opts?: pulumi.InvokeOptions): Promise { + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {}); + return pulumi.runtime.invoke("dynatrace:index/getApplicationDetectionRules:getApplicationDetectionRules", { + }, opts); +} + +/** + * A collection of values returned by getApplicationDetectionRules. + */ +export interface GetApplicationDetectionRulesResult { + /** + * The provider-assigned unique ID for this managed resource. + */ + readonly id: string; + readonly values: outputs.GetApplicationDetectionRulesValue[]; +} +/** + * The application detection rules data source allows retrieval of all existing rules. + * + * ## Example Usage + * + * ```typescript + * import * as pulumi from "@pulumi/pulumi"; + * import * as dynatrace from "@pulumi/dynatrace"; + * + * const test = dynatrace.getApplicationDetectionRules({}); + * export const applicationDetectionRules = test; + * ``` + */ +export function getApplicationDetectionRulesOutput(opts?: pulumi.InvokeOutputOptions): pulumi.Output { + opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {}); + return pulumi.runtime.invokeOutput("dynatrace:index/getApplicationDetectionRules:getApplicationDetectionRules", { + }, opts); +} diff --git a/sdk/nodejs/index.ts b/sdk/nodejs/index.ts index 98bca7cf..0fe585fc 100644 --- a/sdk/nodejs/index.ts +++ b/sdk/nodejs/index.ts @@ -610,6 +610,11 @@ export const getApplication: typeof import("./getApplication").getApplication = export const getApplicationOutput: typeof import("./getApplication").getApplicationOutput = null as any; utilities.lazyLoad(exports, ["getApplication","getApplicationOutput"], () => require("./getApplication")); +export { GetApplicationDetectionRulesResult } from "./getApplicationDetectionRules"; +export const getApplicationDetectionRules: typeof import("./getApplicationDetectionRules").getApplicationDetectionRules = null as any; +export const getApplicationDetectionRulesOutput: typeof import("./getApplicationDetectionRules").getApplicationDetectionRulesOutput = null as any; +utilities.lazyLoad(exports, ["getApplicationDetectionRules","getApplicationDetectionRulesOutput"], () => require("./getApplicationDetectionRules")); + export { GetAttackAlertingArgs, GetAttackAlertingResult, GetAttackAlertingOutputArgs } from "./getAttackAlerting"; export const getAttackAlerting: typeof import("./getAttackAlerting").getAttackAlerting = null as any; export const getAttackAlertingOutput: typeof import("./getAttackAlerting").getAttackAlertingOutput = null as any; diff --git a/sdk/nodejs/jsonDashboardBase.ts b/sdk/nodejs/jsonDashboardBase.ts index c5cc094c..0e5ea18d 100644 --- a/sdk/nodejs/jsonDashboardBase.ts +++ b/sdk/nodejs/jsonDashboardBase.ts @@ -33,7 +33,7 @@ export class JsonDashboardBase extends pulumi.CustomResource { } /** - * This attribute exists for backwards compatibility. You do not have to define it. + * Contains the JSON Code of the Dashboard */ public readonly contents!: pulumi.Output; @@ -44,7 +44,7 @@ export class JsonDashboardBase extends pulumi.CustomResource { * @param args The arguments to use to populate this resource's properties. * @param opts A bag of options that control this resource's behavior. */ - constructor(name: string, args?: JsonDashboardBaseArgs, opts?: pulumi.CustomResourceOptions) + constructor(name: string, args: JsonDashboardBaseArgs, opts?: pulumi.CustomResourceOptions) constructor(name: string, argsOrState?: JsonDashboardBaseArgs | JsonDashboardBaseState, opts?: pulumi.CustomResourceOptions) { let resourceInputs: pulumi.Inputs = {}; opts = opts || {}; @@ -53,6 +53,9 @@ export class JsonDashboardBase extends pulumi.CustomResource { resourceInputs["contents"] = state ? state.contents : undefined; } else { const args = argsOrState as JsonDashboardBaseArgs | undefined; + if ((!args || args.contents === undefined) && !opts.urn) { + throw new Error("Missing required property 'contents'"); + } resourceInputs["contents"] = args ? args.contents : undefined; } opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts); @@ -65,7 +68,7 @@ export class JsonDashboardBase extends pulumi.CustomResource { */ export interface JsonDashboardBaseState { /** - * This attribute exists for backwards compatibility. You do not have to define it. + * Contains the JSON Code of the Dashboard */ contents?: pulumi.Input; } @@ -75,7 +78,7 @@ export interface JsonDashboardBaseState { */ export interface JsonDashboardBaseArgs { /** - * This attribute exists for backwards compatibility. You do not have to define it. + * Contains the JSON Code of the Dashboard */ - contents?: pulumi.Input; + contents: pulumi.Input; } diff --git a/sdk/nodejs/tsconfig.json b/sdk/nodejs/tsconfig.json index 3d80bda8..68b1c961 100644 --- a/sdk/nodejs/tsconfig.json +++ b/sdk/nodejs/tsconfig.json @@ -136,6 +136,7 @@ "getApiToken.ts", "getApiTokens.ts", "getApplication.ts", + "getApplicationDetectionRules.ts", "getAttackAlerting.ts", "getAutotag.ts", "getAwsCredentials.ts", diff --git a/sdk/nodejs/types/output.ts b/sdk/nodejs/types/output.ts index 74965a9d..17c5393a 100644 --- a/sdk/nodejs/types/output.ts +++ b/sdk/nodejs/types/output.ts @@ -10129,6 +10129,25 @@ export interface GetApiTokensApiToken { token: string; } +export interface GetApplicationDetectionRulesValue { + /** + * Application ID + */ + applicationId: string; + /** + * Application Detection Rule ID + */ + id: string; + /** + * Matcher + */ + matcher: string; + /** + * Pattern + */ + pattern: string; +} + export interface GetDocumentsValue { /** * The unique identifier of the document. diff --git a/sdk/python/pulumiverse_dynatrace/__init__.py b/sdk/python/pulumiverse_dynatrace/__init__.py index ed83b083..a4b7538e 100644 --- a/sdk/python/pulumiverse_dynatrace/__init__.py +++ b/sdk/python/pulumiverse_dynatrace/__init__.py @@ -126,6 +126,7 @@ from .get_api_token import * from .get_api_tokens import * from .get_application import * +from .get_application_detection_rules import * from .get_attack_alerting import * from .get_autotag import * from .get_aws_credentials import * diff --git a/sdk/python/pulumiverse_dynatrace/get_application_detection_rules.py b/sdk/python/pulumiverse_dynatrace/get_application_detection_rules.py new file mode 100644 index 00000000..7bb77550 --- /dev/null +++ b/sdk/python/pulumiverse_dynatrace/get_application_detection_rules.py @@ -0,0 +1,102 @@ +# 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 sys +import pulumi +import pulumi.runtime +from typing import Any, Mapping, Optional, Sequence, Union, overload +if sys.version_info >= (3, 11): + from typing import NotRequired, TypedDict, TypeAlias +else: + from typing_extensions import NotRequired, TypedDict, TypeAlias +from . import _utilities +from . import outputs + +__all__ = [ + 'GetApplicationDetectionRulesResult', + 'AwaitableGetApplicationDetectionRulesResult', + 'get_application_detection_rules', + 'get_application_detection_rules_output', +] + +@pulumi.output_type +class GetApplicationDetectionRulesResult: + """ + A collection of values returned by getApplicationDetectionRules. + """ + def __init__(__self__, id=None, values=None): + if id and not isinstance(id, str): + raise TypeError("Expected argument 'id' to be a str") + pulumi.set(__self__, "id", id) + if values and not isinstance(values, list): + raise TypeError("Expected argument 'values' to be a list") + pulumi.set(__self__, "values", values) + + @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 values(self) -> Sequence['outputs.GetApplicationDetectionRulesValueResult']: + return pulumi.get(self, "values") + + +class AwaitableGetApplicationDetectionRulesResult(GetApplicationDetectionRulesResult): + # pylint: disable=using-constant-test + def __await__(self): + if False: + yield self + return GetApplicationDetectionRulesResult( + id=self.id, + values=self.values) + + +def get_application_detection_rules(opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetApplicationDetectionRulesResult: + """ + The application detection rules data source allows retrieval of all existing rules. + + ## Example Usage + + ```python + import pulumi + import pulumi_dynatrace as dynatrace + + test = dynatrace.get_application_detection_rules() + pulumi.export("applicationDetectionRules", test) + ``` + """ + __args__ = dict() + opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke('dynatrace:index/getApplicationDetectionRules:getApplicationDetectionRules', __args__, opts=opts, typ=GetApplicationDetectionRulesResult).value + + return AwaitableGetApplicationDetectionRulesResult( + id=pulumi.get(__ret__, 'id'), + values=pulumi.get(__ret__, 'values')) +def get_application_detection_rules_output(opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetApplicationDetectionRulesResult]: + """ + The application detection rules data source allows retrieval of all existing rules. + + ## Example Usage + + ```python + import pulumi + import pulumi_dynatrace as dynatrace + + test = dynatrace.get_application_detection_rules() + pulumi.export("applicationDetectionRules", test) + ``` + """ + __args__ = dict() + opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts) + __ret__ = pulumi.runtime.invoke_output('dynatrace:index/getApplicationDetectionRules:getApplicationDetectionRules', __args__, opts=opts, typ=GetApplicationDetectionRulesResult) + return __ret__.apply(lambda __response__: GetApplicationDetectionRulesResult( + id=pulumi.get(__response__, 'id'), + values=pulumi.get(__response__, 'values'))) diff --git a/sdk/python/pulumiverse_dynatrace/json_dashboard_base.py b/sdk/python/pulumiverse_dynatrace/json_dashboard_base.py index abbfc6e6..d2cba308 100644 --- a/sdk/python/pulumiverse_dynatrace/json_dashboard_base.py +++ b/sdk/python/pulumiverse_dynatrace/json_dashboard_base.py @@ -19,24 +19,23 @@ @pulumi.input_type class JsonDashboardBaseArgs: def __init__(__self__, *, - contents: Optional[pulumi.Input[str]] = None): + contents: pulumi.Input[str]): """ The set of arguments for constructing a JsonDashboardBase resource. - :param pulumi.Input[str] contents: This attribute exists for backwards compatibility. You do not have to define it. + :param pulumi.Input[str] contents: Contains the JSON Code of the Dashboard """ - if contents is not None: - pulumi.set(__self__, "contents", contents) + pulumi.set(__self__, "contents", contents) @property @pulumi.getter - def contents(self) -> Optional[pulumi.Input[str]]: + def contents(self) -> pulumi.Input[str]: """ - This attribute exists for backwards compatibility. You do not have to define it. + Contains the JSON Code of the Dashboard """ return pulumi.get(self, "contents") @contents.setter - def contents(self, value: Optional[pulumi.Input[str]]): + def contents(self, value: pulumi.Input[str]): pulumi.set(self, "contents", value) @@ -46,7 +45,7 @@ def __init__(__self__, *, contents: Optional[pulumi.Input[str]] = None): """ Input properties used for looking up and filtering JsonDashboardBase resources. - :param pulumi.Input[str] contents: This attribute exists for backwards compatibility. You do not have to define it. + :param pulumi.Input[str] contents: Contains the JSON Code of the Dashboard """ if contents is not None: pulumi.set(__self__, "contents", contents) @@ -55,7 +54,7 @@ def __init__(__self__, *, @pulumi.getter def contents(self) -> Optional[pulumi.Input[str]]: """ - This attribute exists for backwards compatibility. You do not have to define it. + Contains the JSON Code of the Dashboard """ return pulumi.get(self, "contents") @@ -75,13 +74,13 @@ def __init__(__self__, Create a JsonDashboardBase resource with the given unique name, props, and options. :param str resource_name: The name of the resource. :param pulumi.ResourceOptions opts: Options for the resource. - :param pulumi.Input[str] contents: This attribute exists for backwards compatibility. You do not have to define it. + :param pulumi.Input[str] contents: Contains the JSON Code of the Dashboard """ ... @overload def __init__(__self__, resource_name: str, - args: Optional[JsonDashboardBaseArgs] = None, + args: JsonDashboardBaseArgs, opts: Optional[pulumi.ResourceOptions] = None): """ Create a JsonDashboardBase resource with the given unique name, props, and options. @@ -110,6 +109,8 @@ def _internal_init(__self__, raise TypeError('__props__ is only valid when passed in combination with a valid opts.id to get an existing resource') __props__ = JsonDashboardBaseArgs.__new__(JsonDashboardBaseArgs) + if contents is None and not opts.urn: + raise TypeError("Missing required property 'contents'") __props__.__dict__["contents"] = contents super(JsonDashboardBase, __self__).__init__( 'dynatrace:index/jsonDashboardBase:JsonDashboardBase', @@ -129,7 +130,7 @@ def get(resource_name: str, :param str resource_name: The unique name of the resulting resource. :param pulumi.Input[str] id: The unique provider ID of the resource to lookup. :param pulumi.ResourceOptions opts: Options for the resource. - :param pulumi.Input[str] contents: This attribute exists for backwards compatibility. You do not have to define it. + :param pulumi.Input[str] contents: Contains the JSON Code of the Dashboard """ opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id)) @@ -142,7 +143,7 @@ def get(resource_name: str, @pulumi.getter def contents(self) -> pulumi.Output[str]: """ - This attribute exists for backwards compatibility. You do not have to define it. + Contains the JSON Code of the Dashboard """ return pulumi.get(self, "contents") diff --git a/sdk/python/pulumiverse_dynatrace/outputs.py b/sdk/python/pulumiverse_dynatrace/outputs.py index 88760eb4..c9e4e536 100644 --- a/sdk/python/pulumiverse_dynatrace/outputs.py +++ b/sdk/python/pulumiverse_dynatrace/outputs.py @@ -1805,6 +1805,7 @@ 'XmattersNotificationHeadersHeader', 'GetAlertingProfilesValueResult', 'GetApiTokensApiTokenResult', + 'GetApplicationDetectionRulesValueResult', 'GetDocumentsValueResult', 'GetEntitiesEntityResult', 'GetEntitiesEntityTagResult', @@ -108545,6 +108546,57 @@ def personal_access_token(self) -> Optional[bool]: return pulumi.get(self, "personal_access_token") +@pulumi.output_type +class GetApplicationDetectionRulesValueResult(dict): + def __init__(__self__, *, + application_id: str, + id: str, + matcher: str, + pattern: str): + """ + :param str application_id: Application ID + :param str id: Application Detection Rule ID + :param str matcher: Matcher + :param str pattern: Pattern + """ + pulumi.set(__self__, "application_id", application_id) + pulumi.set(__self__, "id", id) + pulumi.set(__self__, "matcher", matcher) + pulumi.set(__self__, "pattern", pattern) + + @property + @pulumi.getter(name="applicationId") + def application_id(self) -> str: + """ + Application ID + """ + return pulumi.get(self, "application_id") + + @property + @pulumi.getter + def id(self) -> str: + """ + Application Detection Rule ID + """ + return pulumi.get(self, "id") + + @property + @pulumi.getter + def matcher(self) -> str: + """ + Matcher + """ + return pulumi.get(self, "matcher") + + @property + @pulumi.getter + def pattern(self) -> str: + """ + Pattern + """ + return pulumi.get(self, "pattern") + + @pulumi.output_type class GetDocumentsValueResult(dict): def __init__(__self__, *,