All Downloads are FREE. Search and download functionalities are using the official Maven repository.

com.pulumi.gcp.healthcare.kotlin.Hl7StoreArgs.kt Maven / Gradle / Ivy

Go to download

Build cloud applications and infrastructure by combining the safety and reliability of infrastructure as code with the power of the Kotlin programming language.

There is a newer version: 8.10.0.0
Show newest version
@file:Suppress("NAME_SHADOWING", "DEPRECATION")

package com.pulumi.gcp.healthcare.kotlin

import com.pulumi.core.Output
import com.pulumi.core.Output.of
import com.pulumi.gcp.healthcare.Hl7StoreArgs.builder
import com.pulumi.gcp.healthcare.kotlin.inputs.Hl7StoreNotificationConfigArgs
import com.pulumi.gcp.healthcare.kotlin.inputs.Hl7StoreNotificationConfigArgsBuilder
import com.pulumi.gcp.healthcare.kotlin.inputs.Hl7StoreNotificationConfigsArgs
import com.pulumi.gcp.healthcare.kotlin.inputs.Hl7StoreNotificationConfigsArgsBuilder
import com.pulumi.gcp.healthcare.kotlin.inputs.Hl7StoreParserConfigArgs
import com.pulumi.gcp.healthcare.kotlin.inputs.Hl7StoreParserConfigArgsBuilder
import com.pulumi.kotlin.ConvertibleToJava
import com.pulumi.kotlin.PulumiTagMarker
import com.pulumi.kotlin.applySuspend
import kotlin.Boolean
import kotlin.Deprecated
import kotlin.Pair
import kotlin.String
import kotlin.Suppress
import kotlin.Unit
import kotlin.collections.List
import kotlin.collections.Map
import kotlin.jvm.JvmName

/**
 * A Hl7V2Store is a datastore inside a Healthcare dataset that conforms to the FHIR (https://www.hl7.org/hl7V2/STU3/)
 * standard for Healthcare information exchange
 * To get more information about Hl7V2Store, see:
 * * [API documentation](https://cloud.google.com/healthcare/docs/reference/rest/v1/projects.locations.datasets.hl7V2Stores)
 * * How-to Guides
 *     * [Creating a HL7v2 Store](https://cloud.google.com/healthcare/docs/how-tos/hl7v2)
 * ## Example Usage
 * ### Healthcare Hl7 V2 Store Basic
 * 
 * ```typescript
 * import * as pulumi from "@pulumi/pulumi";
 * import * as gcp from "@pulumi/gcp";
 * const topic = new gcp.pubsub.Topic("topic", {name: "hl7-v2-notifications"});
 * const dataset = new gcp.healthcare.Dataset("dataset", {
 *     name: "example-dataset",
 *     location: "us-central1",
 * });
 * const store = new gcp.healthcare.Hl7Store("store", {
 *     name: "example-hl7-v2-store",
 *     dataset: dataset.id,
 *     rejectDuplicateMessage: true,
 *     notificationConfigs: [{
 *         pubsubTopic: topic.id,
 *     }],
 *     labels: {
 *         label1: "labelvalue1",
 *     },
 * });
 * ```
 * ```python
 * import pulumi
 * import pulumi_gcp as gcp
 * topic = gcp.pubsub.Topic("topic", name="hl7-v2-notifications")
 * dataset = gcp.healthcare.Dataset("dataset",
 *     name="example-dataset",
 *     location="us-central1")
 * store = gcp.healthcare.Hl7Store("store",
 *     name="example-hl7-v2-store",
 *     dataset=dataset.id,
 *     reject_duplicate_message=True,
 *     notification_configs=[gcp.healthcare.Hl7StoreNotificationConfigsArgs(
 *         pubsub_topic=topic.id,
 *     )],
 *     labels={
 *         "label1": "labelvalue1",
 *     })
 * ```
 * ```csharp
 * using System.Collections.Generic;
 * using System.Linq;
 * using Pulumi;
 * using Gcp = Pulumi.Gcp;
 * return await Deployment.RunAsync(() =>
 * {
 *     var topic = new Gcp.PubSub.Topic("topic", new()
 *     {
 *         Name = "hl7-v2-notifications",
 *     });
 *     var dataset = new Gcp.Healthcare.Dataset("dataset", new()
 *     {
 *         Name = "example-dataset",
 *         Location = "us-central1",
 *     });
 *     var store = new Gcp.Healthcare.Hl7Store("store", new()
 *     {
 *         Name = "example-hl7-v2-store",
 *         Dataset = dataset.Id,
 *         RejectDuplicateMessage = true,
 *         NotificationConfigs = new[]
 *         {
 *             new Gcp.Healthcare.Inputs.Hl7StoreNotificationConfigsArgs
 *             {
 *                 PubsubTopic = topic.Id,
 *             },
 *         },
 *         Labels =
 *         {
 *             { "label1", "labelvalue1" },
 *         },
 *     });
 * });
 * ```
 * ```go
 * package main
 * import (
 * 	"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/healthcare"
 * 	"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/pubsub"
 * 	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
 * )
 * func main() {
 * 	pulumi.Run(func(ctx *pulumi.Context) error {
 * 		topic, err := pubsub.NewTopic(ctx, "topic", &pubsub.TopicArgs{
 * 			Name: pulumi.String("hl7-v2-notifications"),
 * 		})
 * 		if err != nil {
 * 			return err
 * 		}
 * 		dataset, err := healthcare.NewDataset(ctx, "dataset", &healthcare.DatasetArgs{
 * 			Name:     pulumi.String("example-dataset"),
 * 			Location: pulumi.String("us-central1"),
 * 		})
 * 		if err != nil {
 * 			return err
 * 		}
 * 		_, err = healthcare.NewHl7Store(ctx, "store", &healthcare.Hl7StoreArgs{
 * 			Name:                   pulumi.String("example-hl7-v2-store"),
 * 			Dataset:                dataset.ID(),
 * 			RejectDuplicateMessage: pulumi.Bool(true),
 * 			NotificationConfigs: healthcare.Hl7StoreNotificationConfigsArray{
 * 				&healthcare.Hl7StoreNotificationConfigsArgs{
 * 					PubsubTopic: topic.ID(),
 * 				},
 * 			},
 * 			Labels: pulumi.StringMap{
 * 				"label1": pulumi.String("labelvalue1"),
 * 			},
 * 		})
 * 		if err != nil {
 * 			return err
 * 		}
 * 		return nil
 * 	})
 * }
 * ```
 * ```java
 * package generated_program;
 * import com.pulumi.Context;
 * import com.pulumi.Pulumi;
 * import com.pulumi.core.Output;
 * import com.pulumi.gcp.pubsub.Topic;
 * import com.pulumi.gcp.pubsub.TopicArgs;
 * import com.pulumi.gcp.healthcare.Dataset;
 * import com.pulumi.gcp.healthcare.DatasetArgs;
 * import com.pulumi.gcp.healthcare.Hl7Store;
 * import com.pulumi.gcp.healthcare.Hl7StoreArgs;
 * import com.pulumi.gcp.healthcare.inputs.Hl7StoreNotificationConfigsArgs;
 * import java.util.List;
 * import java.util.ArrayList;
 * import java.util.Map;
 * import java.io.File;
 * import java.nio.file.Files;
 * import java.nio.file.Paths;
 * public class App {
 *     public static void main(String[] args) {
 *         Pulumi.run(App::stack);
 *     }
 *     public static void stack(Context ctx) {
 *         var topic = new Topic("topic", TopicArgs.builder()
 *             .name("hl7-v2-notifications")
 *             .build());
 *         var dataset = new Dataset("dataset", DatasetArgs.builder()
 *             .name("example-dataset")
 *             .location("us-central1")
 *             .build());
 *         var store = new Hl7Store("store", Hl7StoreArgs.builder()
 *             .name("example-hl7-v2-store")
 *             .dataset(dataset.id())
 *             .rejectDuplicateMessage(true)
 *             .notificationConfigs(Hl7StoreNotificationConfigsArgs.builder()
 *                 .pubsubTopic(topic.id())
 *                 .build())
 *             .labels(Map.of("label1", "labelvalue1"))
 *             .build());
 *     }
 * }
 * ```
 * ```yaml
 * resources:
 *   store:
 *     type: gcp:healthcare:Hl7Store
 *     properties:
 *       name: example-hl7-v2-store
 *       dataset: ${dataset.id}
 *       rejectDuplicateMessage: true
 *       notificationConfigs:
 *         - pubsubTopic: ${topic.id}
 *       labels:
 *         label1: labelvalue1
 *   topic:
 *     type: gcp:pubsub:Topic
 *     properties:
 *       name: hl7-v2-notifications
 *   dataset:
 *     type: gcp:healthcare:Dataset
 *     properties:
 *       name: example-dataset
 *       location: us-central1
 * ```
 * 
 * ### Healthcare Hl7 V2 Store Parser Config
 * 
 * ```typescript
 * import * as pulumi from "@pulumi/pulumi";
 * import * as gcp from "@pulumi/gcp";
 * const dataset = new gcp.healthcare.Dataset("dataset", {
 *     name: "example-dataset",
 *     location: "us-central1",
 * });
 * const store = new gcp.healthcare.Hl7Store("store", {
 *     name: "example-hl7-v2-store",
 *     dataset: dataset.id,
 *     parserConfig: {
 *         allowNullHeader: false,
 *         segmentTerminator: "Jw==",
 *         schema: `{
 *   "schemas": [{
 *     "messageSchemaConfigs": {
 *       "ADT_A01": {
 *         "name": "ADT_A01",
 *         "minOccurs": 1,
 *         "maxOccurs": 1,
 *         "members": [{
 *             "segment": {
 *               "type": "MSH",
 *               "minOccurs": 1,
 *               "maxOccurs": 1
 *             }
 *           },
 *           {
 *             "segment": {
 *               "type": "EVN",
 *               "minOccurs": 1,
 *               "maxOccurs": 1
 *             }
 *           },
 *           {
 *             "segment": {
 *               "type": "PID",
 *               "minOccurs": 1,
 *               "maxOccurs": 1
 *             }
 *           },
 *           {
 *             "segment": {
 *               "type": "ZPD",
 *               "minOccurs": 1,
 *               "maxOccurs": 1
 *             }
 *           },
 *           {
 *             "segment": {
 *               "type": "OBX"
 *             }
 *           },
 *           {
 *             "group": {
 *               "name": "PROCEDURE",
 *               "members": [{
 *                   "segment": {
 *                     "type": "PR1",
 *                     "minOccurs": 1,
 *                     "maxOccurs": 1
 *                   }
 *                 },
 *                 {
 *                   "segment": {
 *                     "type": "ROL"
 *                   }
 *                 }
 *               ]
 *             }
 *           },
 *           {
 *             "segment": {
 *               "type": "PDA",
 *               "maxOccurs": 1
 *             }
 *           }
 *         ]
 *       }
 *     }
 *   }],
 *   "types": [{
 *     "type": [{
 *         "name": "ZPD",
 *         "primitive": "VARIES"
 *       }
 *     ]
 *   }],
 *   "ignoreMinOccurs": true
 * }
 * `,
 *     },
 * });
 * ```
 * ```python
 * import pulumi
 * import pulumi_gcp as gcp
 * dataset = gcp.healthcare.Dataset("dataset",
 *     name="example-dataset",
 *     location="us-central1")
 * store = gcp.healthcare.Hl7Store("store",
 *     name="example-hl7-v2-store",
 *     dataset=dataset.id,
 *     parser_config=gcp.healthcare.Hl7StoreParserConfigArgs(
 *         allow_null_header=False,
 *         segment_terminator="Jw==",
 *         schema="""{
 *   "schemas": [{
 *     "messageSchemaConfigs": {
 *       "ADT_A01": {
 *         "name": "ADT_A01",
 *         "minOccurs": 1,
 *         "maxOccurs": 1,
 *         "members": [{
 *             "segment": {
 *               "type": "MSH",
 *               "minOccurs": 1,
 *               "maxOccurs": 1
 *             }
 *           },
 *           {
 *             "segment": {
 *               "type": "EVN",
 *               "minOccurs": 1,
 *               "maxOccurs": 1
 *             }
 *           },
 *           {
 *             "segment": {
 *               "type": "PID",
 *               "minOccurs": 1,
 *               "maxOccurs": 1
 *             }
 *           },
 *           {
 *             "segment": {
 *               "type": "ZPD",
 *               "minOccurs": 1,
 *               "maxOccurs": 1
 *             }
 *           },
 *           {
 *             "segment": {
 *               "type": "OBX"
 *             }
 *           },
 *           {
 *             "group": {
 *               "name": "PROCEDURE",
 *               "members": [{
 *                   "segment": {
 *                     "type": "PR1",
 *                     "minOccurs": 1,
 *                     "maxOccurs": 1
 *                   }
 *                 },
 *                 {
 *                   "segment": {
 *                     "type": "ROL"
 *                   }
 *                 }
 *               ]
 *             }
 *           },
 *           {
 *             "segment": {
 *               "type": "PDA",
 *               "maxOccurs": 1
 *             }
 *           }
 *         ]
 *       }
 *     }
 *   }],
 *   "types": [{
 *     "type": [{
 *         "name": "ZPD",
 *         "primitive": "VARIES"
 *       }
 *     ]
 *   }],
 *   "ignoreMinOccurs": true
 * }
 * """,
 *     ))
 * ```
 * ```csharp
 * using System.Collections.Generic;
 * using System.Linq;
 * using Pulumi;
 * using Gcp = Pulumi.Gcp;
 * return await Deployment.RunAsync(() =>
 * {
 *     var dataset = new Gcp.Healthcare.Dataset("dataset", new()
 *     {
 *         Name = "example-dataset",
 *         Location = "us-central1",
 *     });
 *     var store = new Gcp.Healthcare.Hl7Store("store", new()
 *     {
 *         Name = "example-hl7-v2-store",
 *         Dataset = dataset.Id,
 *         ParserConfig = new Gcp.Healthcare.Inputs.Hl7StoreParserConfigArgs
 *         {
 *             AllowNullHeader = false,
 *             SegmentTerminator = "Jw==",
 *             Schema = @"{
 *   ""schemas"": [{
 *     ""messageSchemaConfigs"": {
 *       ""ADT_A01"": {
 *         ""name"": ""ADT_A01"",
 *         ""minOccurs"": 1,
 *         ""maxOccurs"": 1,
 *         ""members"": [{
 *             ""segment"": {
 *               ""type"": ""MSH"",
 *               ""minOccurs"": 1,
 *               ""maxOccurs"": 1
 *             }
 *           },
 *           {
 *             ""segment"": {
 *               ""type"": ""EVN"",
 *               ""minOccurs"": 1,
 *               ""maxOccurs"": 1
 *             }
 *           },
 *           {
 *             ""segment"": {
 *               ""type"": ""PID"",
 *               ""minOccurs"": 1,
 *               ""maxOccurs"": 1
 *             }
 *           },
 *           {
 *             ""segment"": {
 *               ""type"": ""ZPD"",
 *               ""minOccurs"": 1,
 *               ""maxOccurs"": 1
 *             }
 *           },
 *           {
 *             ""segment"": {
 *               ""type"": ""OBX""
 *             }
 *           },
 *           {
 *             ""group"": {
 *               ""name"": ""PROCEDURE"",
 *               ""members"": [{
 *                   ""segment"": {
 *                     ""type"": ""PR1"",
 *                     ""minOccurs"": 1,
 *                     ""maxOccurs"": 1
 *                   }
 *                 },
 *                 {
 *                   ""segment"": {
 *                     ""type"": ""ROL""
 *                   }
 *                 }
 *               ]
 *             }
 *           },
 *           {
 *             ""segment"": {
 *               ""type"": ""PDA"",
 *               ""maxOccurs"": 1
 *             }
 *           }
 *         ]
 *       }
 *     }
 *   }],
 *   ""types"": [{
 *     ""type"": [{
 *         ""name"": ""ZPD"",
 *         ""primitive"": ""VARIES""
 *       }
 *     ]
 *   }],
 *   ""ignoreMinOccurs"": true
 * }
 * ",
 *         },
 *     });
 * });
 * ```
 * ```go
 * package main
 * import (
 * 	"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/healthcare"
 * 	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
 * )
 * func main() {
 * 	pulumi.Run(func(ctx *pulumi.Context) error {
 * 		dataset, err := healthcare.NewDataset(ctx, "dataset", &healthcare.DatasetArgs{
 * 			Name:     pulumi.String("example-dataset"),
 * 			Location: pulumi.String("us-central1"),
 * 		})
 * 		if err != nil {
 * 			return err
 * 		}
 * 		_, err = healthcare.NewHl7Store(ctx, "store", &healthcare.Hl7StoreArgs{
 * 			Name:    pulumi.String("example-hl7-v2-store"),
 * 			Dataset: dataset.ID(),
 * 			ParserConfig: &healthcare.Hl7StoreParserConfigArgs{
 * 				AllowNullHeader:   pulumi.Bool(false),
 * 				SegmentTerminator: pulumi.String("Jw=="),
 * 				Schema: pulumi.String(`{
 *   "schemas": [{
 *     "messageSchemaConfigs": {
 *       "ADT_A01": {
 *         "name": "ADT_A01",
 *         "minOccurs": 1,
 *         "maxOccurs": 1,
 *         "members": [{
 *             "segment": {
 *               "type": "MSH",
 *               "minOccurs": 1,
 *               "maxOccurs": 1
 *             }
 *           },
 *           {
 *             "segment": {
 *               "type": "EVN",
 *               "minOccurs": 1,
 *               "maxOccurs": 1
 *             }
 *           },
 *           {
 *             "segment": {
 *               "type": "PID",
 *               "minOccurs": 1,
 *               "maxOccurs": 1
 *             }
 *           },
 *           {
 *             "segment": {
 *               "type": "ZPD",
 *               "minOccurs": 1,
 *               "maxOccurs": 1
 *             }
 *           },
 *           {
 *             "segment": {
 *               "type": "OBX"
 *             }
 *           },
 *           {
 *             "group": {
 *               "name": "PROCEDURE",
 *               "members": [{
 *                   "segment": {
 *                     "type": "PR1",
 *                     "minOccurs": 1,
 *                     "maxOccurs": 1
 *                   }
 *                 },
 *                 {
 *                   "segment": {
 *                     "type": "ROL"
 *                   }
 *                 }
 *               ]
 *             }
 *           },
 *           {
 *             "segment": {
 *               "type": "PDA",
 *               "maxOccurs": 1
 *             }
 *           }
 *         ]
 *       }
 *     }
 *   }],
 *   "types": [{
 *     "type": [{
 *         "name": "ZPD",
 *         "primitive": "VARIES"
 *       }
 *     ]
 *   }],
 *   "ignoreMinOccurs": true
 * }
 * `),
 * 			},
 * 		})
 * 		if err != nil {
 * 			return err
 * 		}
 * 		return nil
 * 	})
 * }
 * ```
 * ```java
 * package generated_program;
 * import com.pulumi.Context;
 * import com.pulumi.Pulumi;
 * import com.pulumi.core.Output;
 * import com.pulumi.gcp.healthcare.Dataset;
 * import com.pulumi.gcp.healthcare.DatasetArgs;
 * import com.pulumi.gcp.healthcare.Hl7Store;
 * import com.pulumi.gcp.healthcare.Hl7StoreArgs;
 * import com.pulumi.gcp.healthcare.inputs.Hl7StoreParserConfigArgs;
 * import java.util.List;
 * import java.util.ArrayList;
 * import java.util.Map;
 * import java.io.File;
 * import java.nio.file.Files;
 * import java.nio.file.Paths;
 * public class App {
 *     public static void main(String[] args) {
 *         Pulumi.run(App::stack);
 *     }
 *     public static void stack(Context ctx) {
 *         var dataset = new Dataset("dataset", DatasetArgs.builder()
 *             .name("example-dataset")
 *             .location("us-central1")
 *             .build());
 *         var store = new Hl7Store("store", Hl7StoreArgs.builder()
 *             .name("example-hl7-v2-store")
 *             .dataset(dataset.id())
 *             .parserConfig(Hl7StoreParserConfigArgs.builder()
 *                 .allowNullHeader(false)
 *                 .segmentTerminator("Jw==")
 *                 .schema("""
 * {
 *   "schemas": [{
 *     "messageSchemaConfigs": {
 *       "ADT_A01": {
 *         "name": "ADT_A01",
 *         "minOccurs": 1,
 *         "maxOccurs": 1,
 *         "members": [{
 *             "segment": {
 *               "type": "MSH",
 *               "minOccurs": 1,
 *               "maxOccurs": 1
 *             }
 *           },
 *           {
 *             "segment": {
 *               "type": "EVN",
 *               "minOccurs": 1,
 *               "maxOccurs": 1
 *             }
 *           },
 *           {
 *             "segment": {
 *               "type": "PID",
 *               "minOccurs": 1,
 *               "maxOccurs": 1
 *             }
 *           },
 *           {
 *             "segment": {
 *               "type": "ZPD",
 *               "minOccurs": 1,
 *               "maxOccurs": 1
 *             }
 *           },
 *           {
 *             "segment": {
 *               "type": "OBX"
 *             }
 *           },
 *           {
 *             "group": {
 *               "name": "PROCEDURE",
 *               "members": [{
 *                   "segment": {
 *                     "type": "PR1",
 *                     "minOccurs": 1,
 *                     "maxOccurs": 1
 *                   }
 *                 },
 *                 {
 *                   "segment": {
 *                     "type": "ROL"
 *                   }
 *                 }
 *               ]
 *             }
 *           },
 *           {
 *             "segment": {
 *               "type": "PDA",
 *               "maxOccurs": 1
 *             }
 *           }
 *         ]
 *       }
 *     }
 *   }],
 *   "types": [{
 *     "type": [{
 *         "name": "ZPD",
 *         "primitive": "VARIES"
 *       }
 *     ]
 *   }],
 *   "ignoreMinOccurs": true
 * }
 *                 """)
 *                 .build())
 *             .build());
 *     }
 * }
 * ```
 * ```yaml
 * resources:
 *   store:
 *     type: gcp:healthcare:Hl7Store
 *     properties:
 *       name: example-hl7-v2-store
 *       dataset: ${dataset.id}
 *       parserConfig:
 *         allowNullHeader: false
 *         segmentTerminator: Jw==
 *         schema: |
 *           {
 *             "schemas": [{
 *               "messageSchemaConfigs": {
 *                 "ADT_A01": {
 *                   "name": "ADT_A01",
 *                   "minOccurs": 1,
 *                   "maxOccurs": 1,
 *                   "members": [{
 *                       "segment": {
 *                         "type": "MSH",
 *                         "minOccurs": 1,
 *                         "maxOccurs": 1
 *                       }
 *                     },
 *                     {
 *                       "segment": {
 *                         "type": "EVN",
 *                         "minOccurs": 1,
 *                         "maxOccurs": 1
 *                       }
 *                     },
 *                     {
 *                       "segment": {
 *                         "type": "PID",
 *                         "minOccurs": 1,
 *                         "maxOccurs": 1
 *                       }
 *                     },
 *                     {
 *                       "segment": {
 *                         "type": "ZPD",
 *                         "minOccurs": 1,
 *                         "maxOccurs": 1
 *                       }
 *                     },
 *                     {
 *                       "segment": {
 *                         "type": "OBX"
 *                       }
 *                     },
 *                     {
 *                       "group": {
 *                         "name": "PROCEDURE",
 *                         "members": [{
 *                             "segment": {
 *                               "type": "PR1",
 *                               "minOccurs": 1,
 *                               "maxOccurs": 1
 *                             }
 *                           },
 *                           {
 *                             "segment": {
 *                               "type": "ROL"
 *                             }
 *                           }
 *                         ]
 *                       }
 *                     },
 *                     {
 *                       "segment": {
 *                         "type": "PDA",
 *                         "maxOccurs": 1
 *                       }
 *                     }
 *                   ]
 *                 }
 *               }
 *             }],
 *             "types": [{
 *               "type": [{
 *                   "name": "ZPD",
 *                   "primitive": "VARIES"
 *                 }
 *               ]
 *             }],
 *             "ignoreMinOccurs": true
 *           }
 *   dataset:
 *     type: gcp:healthcare:Dataset
 *     properties:
 *       name: example-dataset
 *       location: us-central1
 * ```
 * 
 * ### Healthcare Hl7 V2 Store Unschematized
 * 
 * ```typescript
 * import * as pulumi from "@pulumi/pulumi";
 * import * as gcp from "@pulumi/gcp";
 * const dataset = new gcp.healthcare.Dataset("dataset", {
 *     name: "example-dataset",
 *     location: "us-central1",
 * });
 * const store = new gcp.healthcare.Hl7Store("store", {
 *     name: "example-hl7-v2-store",
 *     dataset: dataset.id,
 *     parserConfig: {
 *         allowNullHeader: false,
 *         segmentTerminator: "Jw==",
 *         version: "V2",
 *     },
 * });
 * ```
 * ```python
 * import pulumi
 * import pulumi_gcp as gcp
 * dataset = gcp.healthcare.Dataset("dataset",
 *     name="example-dataset",
 *     location="us-central1")
 * store = gcp.healthcare.Hl7Store("store",
 *     name="example-hl7-v2-store",
 *     dataset=dataset.id,
 *     parser_config=gcp.healthcare.Hl7StoreParserConfigArgs(
 *         allow_null_header=False,
 *         segment_terminator="Jw==",
 *         version="V2",
 *     ))
 * ```
 * ```csharp
 * using System.Collections.Generic;
 * using System.Linq;
 * using Pulumi;
 * using Gcp = Pulumi.Gcp;
 * return await Deployment.RunAsync(() =>
 * {
 *     var dataset = new Gcp.Healthcare.Dataset("dataset", new()
 *     {
 *         Name = "example-dataset",
 *         Location = "us-central1",
 *     });
 *     var store = new Gcp.Healthcare.Hl7Store("store", new()
 *     {
 *         Name = "example-hl7-v2-store",
 *         Dataset = dataset.Id,
 *         ParserConfig = new Gcp.Healthcare.Inputs.Hl7StoreParserConfigArgs
 *         {
 *             AllowNullHeader = false,
 *             SegmentTerminator = "Jw==",
 *             Version = "V2",
 *         },
 *     });
 * });
 * ```
 * ```go
 * package main
 * import (
 * 	"github.com/pulumi/pulumi-gcp/sdk/v7/go/gcp/healthcare"
 * 	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
 * )
 * func main() {
 * 	pulumi.Run(func(ctx *pulumi.Context) error {
 * 		dataset, err := healthcare.NewDataset(ctx, "dataset", &healthcare.DatasetArgs{
 * 			Name:     pulumi.String("example-dataset"),
 * 			Location: pulumi.String("us-central1"),
 * 		})
 * 		if err != nil {
 * 			return err
 * 		}
 * 		_, err = healthcare.NewHl7Store(ctx, "store", &healthcare.Hl7StoreArgs{
 * 			Name:    pulumi.String("example-hl7-v2-store"),
 * 			Dataset: dataset.ID(),
 * 			ParserConfig: &healthcare.Hl7StoreParserConfigArgs{
 * 				AllowNullHeader:   pulumi.Bool(false),
 * 				SegmentTerminator: pulumi.String("Jw=="),
 * 				Version:           pulumi.String("V2"),
 * 			},
 * 		})
 * 		if err != nil {
 * 			return err
 * 		}
 * 		return nil
 * 	})
 * }
 * ```
 * ```java
 * package generated_program;
 * import com.pulumi.Context;
 * import com.pulumi.Pulumi;
 * import com.pulumi.core.Output;
 * import com.pulumi.gcp.healthcare.Dataset;
 * import com.pulumi.gcp.healthcare.DatasetArgs;
 * import com.pulumi.gcp.healthcare.Hl7Store;
 * import com.pulumi.gcp.healthcare.Hl7StoreArgs;
 * import com.pulumi.gcp.healthcare.inputs.Hl7StoreParserConfigArgs;
 * import java.util.List;
 * import java.util.ArrayList;
 * import java.util.Map;
 * import java.io.File;
 * import java.nio.file.Files;
 * import java.nio.file.Paths;
 * public class App {
 *     public static void main(String[] args) {
 *         Pulumi.run(App::stack);
 *     }
 *     public static void stack(Context ctx) {
 *         var dataset = new Dataset("dataset", DatasetArgs.builder()
 *             .name("example-dataset")
 *             .location("us-central1")
 *             .build());
 *         var store = new Hl7Store("store", Hl7StoreArgs.builder()
 *             .name("example-hl7-v2-store")
 *             .dataset(dataset.id())
 *             .parserConfig(Hl7StoreParserConfigArgs.builder()
 *                 .allowNullHeader(false)
 *                 .segmentTerminator("Jw==")
 *                 .version("V2")
 *                 .build())
 *             .build());
 *     }
 * }
 * ```
 * ```yaml
 * resources:
 *   store:
 *     type: gcp:healthcare:Hl7Store
 *     properties:
 *       name: example-hl7-v2-store
 *       dataset: ${dataset.id}
 *       parserConfig:
 *         allowNullHeader: false
 *         segmentTerminator: Jw==
 *         version: V2
 *   dataset:
 *     type: gcp:healthcare:Dataset
 *     properties:
 *       name: example-dataset
 *       location: us-central1
 * ```
 * 
 * ## Import
 * Hl7V2Store can be imported using any of these accepted formats:
 * * `{{dataset}}/hl7V2Stores/{{name}}`
 * * `{{dataset}}/{{name}}`
 * When using the `pulumi import` command, Hl7V2Store can be imported using one of the formats above. For example:
 * ```sh
 * $ pulumi import gcp:healthcare/hl7Store:Hl7Store default {{dataset}}/hl7V2Stores/{{name}}
 * ```
 * ```sh
 * $ pulumi import gcp:healthcare/hl7Store:Hl7Store default {{dataset}}/{{name}}
 * ```
 * @property dataset Identifies the dataset addressed by this request. Must be in the format
 * 'projects/{project}/locations/{location}/datasets/{dataset}'
 * - - -
 * @property labels User-supplied key-value pairs used to organize HL7v2 stores.
 * Label keys must be between 1 and 63 characters long, have a UTF-8 encoding of maximum 128 bytes, and must
 * conform to the following PCRE regular expression: [\p{Ll}\p{Lo}][\p{Ll}\p{Lo}\p{N}_-]{0,62}
 * Label values are optional, must be between 1 and 63 characters long, have a UTF-8 encoding of maximum 128
 * bytes, and must conform to the following PCRE regular expression: [\p{Ll}\p{Lo}\p{N}_-]{0,63}
 * No more than 64 labels can be associated with a given store.
 * An object containing a list of "key": value pairs.
 * Example: { "name": "wrench", "mass": "1.3kg", "count": "3" }.
 * **Note**: This field is non-authoritative, and will only manage the labels present in your configuration.
 * Please refer to the field `effective_labels` for all of the labels present on the resource.
 * @property name The resource name for the Hl7V2Store.
 * ** Changing this property may recreate the Hl7v2 store (removing all data) **
 * @property notificationConfig (Optional, Deprecated)
 * A nested object resource
 * Structure is documented below.
 * > **Warning:** `notification_config` is deprecated and will be removed in a future major release. Use `notification_configs` instead.
 * @property notificationConfigs A list of notification configs. Each configuration uses a filter to determine whether to publish a
 * message (both Ingest & Create) on the corresponding notification destination. Only the message name
 * is sent as part of the notification. Supplied by the client.
 * Structure is documented below.
 * @property parserConfig A nested object resource
 * Structure is documented below.
 * @property rejectDuplicateMessage Determines whether duplicate messages are allowed.
 */
public data class Hl7StoreArgs(
    public val dataset: Output? = null,
    public val labels: Output>? = null,
    public val name: Output? = null,
    @Deprecated(
        message = """
  `notification_config` is deprecated and will be removed in a future major release. Use
      `notification_configs` instead.
  """,
    )
    public val notificationConfig: Output? = null,
    public val notificationConfigs: Output>? = null,
    public val parserConfig: Output? = null,
    public val rejectDuplicateMessage: Output? = null,
) : ConvertibleToJava {
    override fun toJava(): com.pulumi.gcp.healthcare.Hl7StoreArgs =
        com.pulumi.gcp.healthcare.Hl7StoreArgs.builder()
            .dataset(dataset?.applyValue({ args0 -> args0 }))
            .labels(labels?.applyValue({ args0 -> args0.map({ args0 -> args0.key.to(args0.value) }).toMap() }))
            .name(name?.applyValue({ args0 -> args0 }))
            .notificationConfig(
                notificationConfig?.applyValue({ args0 ->
                    args0.let({ args0 ->
                        args0.toJava()
                    })
                }),
            )
            .notificationConfigs(
                notificationConfigs?.applyValue({ args0 ->
                    args0.map({ args0 ->
                        args0.let({ args0 -> args0.toJava() })
                    })
                }),
            )
            .parserConfig(parserConfig?.applyValue({ args0 -> args0.let({ args0 -> args0.toJava() }) }))
            .rejectDuplicateMessage(rejectDuplicateMessage?.applyValue({ args0 -> args0 })).build()
}

/**
 * Builder for [Hl7StoreArgs].
 */
@PulumiTagMarker
public class Hl7StoreArgsBuilder internal constructor() {
    private var dataset: Output? = null

    private var labels: Output>? = null

    private var name: Output? = null

    private var notificationConfig: Output? = null

    private var notificationConfigs: Output>? = null

    private var parserConfig: Output? = null

    private var rejectDuplicateMessage: Output? = null

    /**
     * @param value Identifies the dataset addressed by this request. Must be in the format
     * 'projects/{project}/locations/{location}/datasets/{dataset}'
     * - - -
     */
    @JvmName("qrqvmknypvmbksqi")
    public suspend fun dataset(`value`: Output) {
        this.dataset = value
    }

    /**
     * @param value User-supplied key-value pairs used to organize HL7v2 stores.
     * Label keys must be between 1 and 63 characters long, have a UTF-8 encoding of maximum 128 bytes, and must
     * conform to the following PCRE regular expression: [\p{Ll}\p{Lo}][\p{Ll}\p{Lo}\p{N}_-]{0,62}
     * Label values are optional, must be between 1 and 63 characters long, have a UTF-8 encoding of maximum 128
     * bytes, and must conform to the following PCRE regular expression: [\p{Ll}\p{Lo}\p{N}_-]{0,63}
     * No more than 64 labels can be associated with a given store.
     * An object containing a list of "key": value pairs.
     * Example: { "name": "wrench", "mass": "1.3kg", "count": "3" }.
     * **Note**: This field is non-authoritative, and will only manage the labels present in your configuration.
     * Please refer to the field `effective_labels` for all of the labels present on the resource.
     */
    @JvmName("qifuucjayctfgbed")
    public suspend fun labels(`value`: Output>) {
        this.labels = value
    }

    /**
     * @param value The resource name for the Hl7V2Store.
     * ** Changing this property may recreate the Hl7v2 store (removing all data) **
     */
    @JvmName("juycxumlpqydwqgr")
    public suspend fun name(`value`: Output) {
        this.name = value
    }

    /**
     * @param value (Optional, Deprecated)
     * A nested object resource
     * Structure is documented below.
     * > **Warning:** `notification_config` is deprecated and will be removed in a future major release. Use `notification_configs` instead.
     */
    @Deprecated(
        message = """
  `notification_config` is deprecated and will be removed in a future major release. Use
      `notification_configs` instead.
  """,
    )
    @JvmName("ejqdvicertisblhh")
    public suspend fun notificationConfig(`value`: Output) {
        this.notificationConfig = value
    }

    /**
     * @param value A list of notification configs. Each configuration uses a filter to determine whether to publish a
     * message (both Ingest & Create) on the corresponding notification destination. Only the message name
     * is sent as part of the notification. Supplied by the client.
     * Structure is documented below.
     */
    @JvmName("myhilojfyxiogmum")
    public suspend fun notificationConfigs(`value`: Output>) {
        this.notificationConfigs = value
    }

    @JvmName("qaktlvljuwbfahts")
    public suspend fun notificationConfigs(vararg values: Output) {
        this.notificationConfigs = Output.all(values.asList())
    }

    /**
     * @param values A list of notification configs. Each configuration uses a filter to determine whether to publish a
     * message (both Ingest & Create) on the corresponding notification destination. Only the message name
     * is sent as part of the notification. Supplied by the client.
     * Structure is documented below.
     */
    @JvmName("ihdcbhdmbdmwfjgv")
    public suspend fun notificationConfigs(values: List>) {
        this.notificationConfigs = Output.all(values)
    }

    /**
     * @param value A nested object resource
     * Structure is documented below.
     */
    @JvmName("fpdkvmcdfikgsfvp")
    public suspend fun parserConfig(`value`: Output) {
        this.parserConfig = value
    }

    /**
     * @param value Determines whether duplicate messages are allowed.
     */
    @JvmName("egsqsmackvdcjgky")
    public suspend fun rejectDuplicateMessage(`value`: Output) {
        this.rejectDuplicateMessage = value
    }

    /**
     * @param value Identifies the dataset addressed by this request. Must be in the format
     * 'projects/{project}/locations/{location}/datasets/{dataset}'
     * - - -
     */
    @JvmName("okwbpdnsfcajvbef")
    public suspend fun dataset(`value`: String?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.dataset = mapped
    }

    /**
     * @param value User-supplied key-value pairs used to organize HL7v2 stores.
     * Label keys must be between 1 and 63 characters long, have a UTF-8 encoding of maximum 128 bytes, and must
     * conform to the following PCRE regular expression: [\p{Ll}\p{Lo}][\p{Ll}\p{Lo}\p{N}_-]{0,62}
     * Label values are optional, must be between 1 and 63 characters long, have a UTF-8 encoding of maximum 128
     * bytes, and must conform to the following PCRE regular expression: [\p{Ll}\p{Lo}\p{N}_-]{0,63}
     * No more than 64 labels can be associated with a given store.
     * An object containing a list of "key": value pairs.
     * Example: { "name": "wrench", "mass": "1.3kg", "count": "3" }.
     * **Note**: This field is non-authoritative, and will only manage the labels present in your configuration.
     * Please refer to the field `effective_labels` for all of the labels present on the resource.
     */
    @JvmName("lawknxvfnfcvshjy")
    public suspend fun labels(`value`: Map?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.labels = mapped
    }

    /**
     * @param values User-supplied key-value pairs used to organize HL7v2 stores.
     * Label keys must be between 1 and 63 characters long, have a UTF-8 encoding of maximum 128 bytes, and must
     * conform to the following PCRE regular expression: [\p{Ll}\p{Lo}][\p{Ll}\p{Lo}\p{N}_-]{0,62}
     * Label values are optional, must be between 1 and 63 characters long, have a UTF-8 encoding of maximum 128
     * bytes, and must conform to the following PCRE regular expression: [\p{Ll}\p{Lo}\p{N}_-]{0,63}
     * No more than 64 labels can be associated with a given store.
     * An object containing a list of "key": value pairs.
     * Example: { "name": "wrench", "mass": "1.3kg", "count": "3" }.
     * **Note**: This field is non-authoritative, and will only manage the labels present in your configuration.
     * Please refer to the field `effective_labels` for all of the labels present on the resource.
     */
    @JvmName("mobqimnonamilkdh")
    public fun labels(vararg values: Pair) {
        val toBeMapped = values.toMap()
        val mapped = toBeMapped.let({ args0 -> of(args0) })
        this.labels = mapped
    }

    /**
     * @param value The resource name for the Hl7V2Store.
     * ** Changing this property may recreate the Hl7v2 store (removing all data) **
     */
    @JvmName("enylhlphfimgiorl")
    public suspend fun name(`value`: String?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.name = mapped
    }

    /**
     * @param value (Optional, Deprecated)
     * A nested object resource
     * Structure is documented below.
     * > **Warning:** `notification_config` is deprecated and will be removed in a future major release. Use `notification_configs` instead.
     */
    @Deprecated(
        message = """
  `notification_config` is deprecated and will be removed in a future major release. Use
      `notification_configs` instead.
  """,
    )
    @JvmName("glqgxprnaqptdtbx")
    public suspend fun notificationConfig(`value`: Hl7StoreNotificationConfigArgs?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.notificationConfig = mapped
    }

    /**
     * @param argument (Optional, Deprecated)
     * A nested object resource
     * Structure is documented below.
     * > **Warning:** `notification_config` is deprecated and will be removed in a future major release. Use `notification_configs` instead.
     */
    @Deprecated(
        message = """
  `notification_config` is deprecated and will be removed in a future major release. Use
      `notification_configs` instead.
  """,
    )
    @JvmName("ueiselpkqdyvsxmr")
    public suspend fun notificationConfig(argument: suspend Hl7StoreNotificationConfigArgsBuilder.() -> Unit) {
        val toBeMapped = Hl7StoreNotificationConfigArgsBuilder().applySuspend { argument() }.build()
        val mapped = of(toBeMapped)
        this.notificationConfig = mapped
    }

    /**
     * @param value A list of notification configs. Each configuration uses a filter to determine whether to publish a
     * message (both Ingest & Create) on the corresponding notification destination. Only the message name
     * is sent as part of the notification. Supplied by the client.
     * Structure is documented below.
     */
    @JvmName("lnmothrtwhinjvmh")
    public suspend fun notificationConfigs(`value`: List?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.notificationConfigs = mapped
    }

    /**
     * @param argument A list of notification configs. Each configuration uses a filter to determine whether to publish a
     * message (both Ingest & Create) on the corresponding notification destination. Only the message name
     * is sent as part of the notification. Supplied by the client.
     * Structure is documented below.
     */
    @JvmName("eclvclnvlcuduspk")
    public suspend fun notificationConfigs(argument: List Unit>) {
        val toBeMapped = argument.toList().map {
            Hl7StoreNotificationConfigsArgsBuilder().applySuspend {
                it()
            }.build()
        }
        val mapped = of(toBeMapped)
        this.notificationConfigs = mapped
    }

    /**
     * @param argument A list of notification configs. Each configuration uses a filter to determine whether to publish a
     * message (both Ingest & Create) on the corresponding notification destination. Only the message name
     * is sent as part of the notification. Supplied by the client.
     * Structure is documented below.
     */
    @JvmName("uxnirpsyhicwucee")
    public suspend fun notificationConfigs(vararg argument: suspend Hl7StoreNotificationConfigsArgsBuilder.() -> Unit) {
        val toBeMapped = argument.toList().map {
            Hl7StoreNotificationConfigsArgsBuilder().applySuspend {
                it()
            }.build()
        }
        val mapped = of(toBeMapped)
        this.notificationConfigs = mapped
    }

    /**
     * @param argument A list of notification configs. Each configuration uses a filter to determine whether to publish a
     * message (both Ingest & Create) on the corresponding notification destination. Only the message name
     * is sent as part of the notification. Supplied by the client.
     * Structure is documented below.
     */
    @JvmName("onrsgvjneevmxvxb")
    public suspend fun notificationConfigs(argument: suspend Hl7StoreNotificationConfigsArgsBuilder.() -> Unit) {
        val toBeMapped = listOf(
            Hl7StoreNotificationConfigsArgsBuilder().applySuspend {
                argument()
            }.build(),
        )
        val mapped = of(toBeMapped)
        this.notificationConfigs = mapped
    }

    /**
     * @param values A list of notification configs. Each configuration uses a filter to determine whether to publish a
     * message (both Ingest & Create) on the corresponding notification destination. Only the message name
     * is sent as part of the notification. Supplied by the client.
     * Structure is documented below.
     */
    @JvmName("dsqgoafhfifnsnfq")
    public suspend fun notificationConfigs(vararg values: Hl7StoreNotificationConfigsArgs) {
        val toBeMapped = values.toList()
        val mapped = toBeMapped.let({ args0 -> of(args0) })
        this.notificationConfigs = mapped
    }

    /**
     * @param value A nested object resource
     * Structure is documented below.
     */
    @JvmName("pulettrdjqyarlbc")
    public suspend fun parserConfig(`value`: Hl7StoreParserConfigArgs?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.parserConfig = mapped
    }

    /**
     * @param argument A nested object resource
     * Structure is documented below.
     */
    @JvmName("enfdnhunigkvmxhc")
    public suspend fun parserConfig(argument: suspend Hl7StoreParserConfigArgsBuilder.() -> Unit) {
        val toBeMapped = Hl7StoreParserConfigArgsBuilder().applySuspend { argument() }.build()
        val mapped = of(toBeMapped)
        this.parserConfig = mapped
    }

    /**
     * @param value Determines whether duplicate messages are allowed.
     */
    @JvmName("jbnbgveirveanrvr")
    public suspend fun rejectDuplicateMessage(`value`: Boolean?) {
        val toBeMapped = value
        val mapped = toBeMapped?.let({ args0 -> of(args0) })
        this.rejectDuplicateMessage = mapped
    }

    internal fun build(): Hl7StoreArgs = Hl7StoreArgs(
        dataset = dataset,
        labels = labels,
        name = name,
        notificationConfig = notificationConfig,
        notificationConfigs = notificationConfigs,
        parserConfig = parserConfig,
        rejectDuplicateMessage = rejectDuplicateMessage,
    )
}




© 2015 - 2024 Weber Informatics LLC | Privacy Policy