text: # coding=utf-8
  # *** WARNING: this file was generated by the Pulumi SDK Generator. ***
  # *** Do not edit by hand unless you're certain you know what you are doing! ***
  
  import warnings
  import pulumi
  import pulumi.runtime
  from typing import Any, Mapping, Optional, Sequence, Union
  from ... import _utilities, _tables
  
  __all__ = [
      'AssignmentPrincipalArgs',
      'ConnectorMappingAvailabilityArgs',
      'ConnectorMappingCompleteOperationArgs',
      'ConnectorMappingErrorManagementArgs',
      'ConnectorMappingFormatArgs',
      'ConnectorMappingPropertiesArgs',
      'ConnectorMappingStructureArgs',
      'HubBillingInfoFormatArgs',
      'KpiAliasArgs',
      'KpiExtractArgs',
      'KpiThresholdsArgs',
      'ParticipantProfilePropertyReferenceArgs',
      'ParticipantPropertyReferenceArgs',
      'PredictionGradesArgs',
      'PredictionMappingsArgs',
      'ProfileEnumValidValuesFormatArgs',
      'PropertyDefinitionArgs',
      'RelationshipLinkFieldMappingArgs',
      'RelationshipTypeFieldMappingArgs',
      'RelationshipTypeMappingArgs',
      'ResourceSetDescriptionArgs',
      'StrongIdArgs',
      'TypePropertiesMappingArgs',
  ]
  
  @pulumi.input_type
  class AssignmentPrincipalArgs:
      def __init__(__self__, *,
                   principal_id: pulumi.Input[str],
                   principal_type: pulumi.Input[str],
                   principal_metadata: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None):
          """
          The AssignmentPrincipal
          :param pulumi.Input[str] principal_id: The principal id being assigned to.
          :param pulumi.Input[str] principal_type: The Type of the principal ID.
          :param pulumi.Input[Mapping[str, pulumi.Input[str]]] principal_metadata: Other metadata for the principal.
          """
          pulumi.set(__self__, "principal_id", principal_id)
          pulumi.set(__self__, "principal_type", principal_type)
          if principal_metadata is not None:
              pulumi.set(__self__, "principal_metadata", principal_metadata)
  
      @property
      @pulumi.getter(name="principalId")
      def principal_id(self) -> pulumi.Input[str]:
          """
          The principal id being assigned to.
          """
          return pulumi.get(self, "principal_id")
  
      @principal_id.setter
      def principal_id(self, value: pulumi.Input[str]):
          pulumi.set(self, "principal_id", value)
  
      @property
      @pulumi.getter(name="principalType")
      def principal_type(self) -> pulumi.Input[str]:
          """
          The Type of the principal ID.
          """
          return pulumi.get(self, "principal_type")
  
      @principal_type.setter
      def principal_type(self, value: pulumi.Input[str]):
          pulumi.set(self, "principal_type", value)
  
      @property
      @pulumi.getter(name="principalMetadata")
      def principal_metadata(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
          """
          Other metadata for the principal.
          """
          return pulumi.get(self, "principal_metadata")
  
      @principal_metadata.setter
      def principal_metadata(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
          pulumi.set(self, "principal_metadata", value)
  
  
  @pulumi.input_type
  class ConnectorMappingAvailabilityArgs:
      def __init__(__self__, *,
                   interval: pulumi.Input[int],
                   frequency: Optional[pulumi.Input[str]] = None):
          """
          Connector mapping property availability.
          :param pulumi.Input[int] interval: The interval of the given frequency to use.
          :param pulumi.Input[str] frequency: The frequency to update.
          """
          pulumi.set(__self__, "interval", interval)
          if frequency is not None:
              pulumi.set(__self__, "frequency", frequency)
  
      @property
      @pulumi.getter
      def interval(self) -> pulumi.Input[int]:
          """
          The interval of the given frequency to use.
          """
          return pulumi.get(self, "interval")
  
      @interval.setter
      def interval(self, value: pulumi.Input[int]):
          pulumi.set(self, "interval", value)
  
      @property
      @pulumi.getter
      def frequency(self) -> Optional[pulumi.Input[str]]:
          """
          The frequency to update.
          """
          return pulumi.get(self, "frequency")
  
      @frequency.setter
      def frequency(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "frequency", value)
  
  
  @pulumi.input_type
  class ConnectorMappingCompleteOperationArgs:
      def __init__(__self__, *,
                   completion_operation_type: Optional[pulumi.Input[str]] = None,
                   destination_folder: Optional[pulumi.Input[str]] = None):
          """
          The complete operation.
          :param pulumi.Input[str] completion_operation_type: The type of completion operation.
          :param pulumi.Input[str] destination_folder: The destination folder where files will be moved to once the import is done.
          """
          if completion_operation_type is not None:
              pulumi.set(__self__, "completion_operation_type", completion_operation_type)
          if destination_folder is not None:
              pulumi.set(__self__, "destination_folder", destination_folder)
  
      @property
      @pulumi.getter(name="completionOperationType")
      def completion_operation_type(self) -> Optional[pulumi.Input[str]]:
          """
          The type of completion operation.
          """
          return pulumi.get(self, "completion_operation_type")
  
      @completion_operation_type.setter
      def completion_operation_type(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "completion_operation_type", value)
  
      @property
      @pulumi.getter(name="destinationFolder")
      def destination_folder(self) -> Optional[pulumi.Input[str]]:
          """
          The destination folder where files will be moved to once the import is done.
          """
          return pulumi.get(self, "destination_folder")
  
      @destination_folder.setter
      def destination_folder(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "destination_folder", value)
  
  
  @pulumi.input_type
  class ConnectorMappingErrorManagementArgs:
      def __init__(__self__, *,
                   error_management_type: pulumi.Input[str],
                   error_limit: Optional[pulumi.Input[int]] = None):
          """
          The error management.
          :param pulumi.Input[str] error_management_type: The type of error management to use for the mapping.
          :param pulumi.Input[int] error_limit: The error limit allowed while importing data.
          """
          pulumi.set(__self__, "error_management_type", error_management_type)
          if error_limit is not None:
              pulumi.set(__self__, "error_limit", error_limit)
  
      @property
      @pulumi.getter(name="errorManagementType")
      def error_management_type(self) -> pulumi.Input[str]:
          """
          The type of error management to use for the mapping.
          """
          return pulumi.get(self, "error_management_type")
  
      @error_management_type.setter
      def error_management_type(self, value: pulumi.Input[str]):
          pulumi.set(self, "error_management_type", value)
  
      @property
      @pulumi.getter(name="errorLimit")
      def error_limit(self) -> Optional[pulumi.Input[int]]:
          """
          The error limit allowed while importing data.
          """
          return pulumi.get(self, "error_limit")
  
      @error_limit.setter
      def error_limit(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "error_limit", value)
  
  
  @pulumi.input_type
  class ConnectorMappingFormatArgs:
      def __init__(__self__, *,
                   format_type: pulumi.Input[str],
                   accept_language: Optional[pulumi.Input[str]] = None,
                   array_separator: Optional[pulumi.Input[str]] = None,
                   column_delimiter: Optional[pulumi.Input[str]] = None,
                   quote_character: Optional[pulumi.Input[str]] = None,
                   quote_escape_character: Optional[pulumi.Input[str]] = None):
          """
          Connector mapping property format.
          :param pulumi.Input[str] format_type: The type mapping format.
          :param pulumi.Input[str] accept_language: The oData language.
          :param pulumi.Input[str] array_separator: Character separating array elements.
          :param pulumi.Input[str] column_delimiter: The character that signifies a break between columns.
          :param pulumi.Input[str] quote_character: Quote character, used to indicate enquoted fields.
          :param pulumi.Input[str] quote_escape_character: Escape character for quotes, can be the same as the quoteCharacter.
          """
          pulumi.set(__self__, "format_type", format_type)
          if accept_language is not None:
              pulumi.set(__self__, "accept_language", accept_language)
          if array_separator is not None:
              pulumi.set(__self__, "array_separator", array_separator)
          if column_delimiter is not None:
              pulumi.set(__self__, "column_delimiter", column_delimiter)
          if quote_character is not None:
              pulumi.set(__self__, "quote_character", quote_character)
          if quote_escape_character is not None:
              pulumi.set(__self__, "quote_escape_character", quote_escape_character)
  
      @property
      @pulumi.getter(name="formatType")
      def format_type(self) -> pulumi.Input[str]:
          """
          The type mapping format.
          """
          return pulumi.get(self, "format_type")
  
      @format_type.setter
      def format_type(self, value: pulumi.Input[str]):
          pulumi.set(self, "format_type", value)
  
      @property
      @pulumi.getter(name="acceptLanguage")
      def accept_language(self) -> Optional[pulumi.Input[str]]:
          """
          The oData language.
          """
          return pulumi.get(self, "accept_language")
  
      @accept_language.setter
      def accept_language(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "accept_language", value)
  
      @property
      @pulumi.getter(name="arraySeparator")
      def array_separator(self) -> Optional[pulumi.Input[str]]:
          """
          Character separating array elements.
          """
          return pulumi.get(self, "array_separator")
  
      @array_separator.setter
      def array_separator(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "array_separator", value)
  
      @property
      @pulumi.getter(name="columnDelimiter")
      def column_delimiter(self) -> Optional[pulumi.Input[str]]:
          """
          The character that signifies a break between columns.
          """
          return pulumi.get(self, "column_delimiter")
  
      @column_delimiter.setter
      def column_delimiter(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "column_delimiter", value)
  
      @property
      @pulumi.getter(name="quoteCharacter")
      def quote_character(self) -> Optional[pulumi.Input[str]]:
          """
          Quote character, used to indicate enquoted fields.
          """
          return pulumi.get(self, "quote_character")
  
      @quote_character.setter
      def quote_character(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "quote_character", value)
  
      @property
      @pulumi.getter(name="quoteEscapeCharacter")
      def quote_escape_character(self) -> Optional[pulumi.Input[str]]:
          """
          Escape character for quotes, can be the same as the quoteCharacter.
          """
          return pulumi.get(self, "quote_escape_character")
  
      @quote_escape_character.setter
      def quote_escape_character(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "quote_escape_character", value)
  
  
  @pulumi.input_type
  class ConnectorMappingPropertiesArgs:
      def __init__(__self__, *,
                   availability: pulumi.Input['ConnectorMappingAvailabilityArgs'],
                   complete_operation: pulumi.Input['ConnectorMappingCompleteOperationArgs'],
                   error_management: pulumi.Input['ConnectorMappingErrorManagementArgs'],
                   format: pulumi.Input['ConnectorMappingFormatArgs'],
                   structure: pulumi.Input[Sequence[pulumi.Input['ConnectorMappingStructureArgs']]],
                   file_filter: Optional[pulumi.Input[str]] = None,
                   folder_path: Optional[pulumi.Input[str]] = None,
                   has_header: Optional[pulumi.Input[bool]] = None):
          """
          The connector mapping properties.
          :param pulumi.Input['ConnectorMappingAvailabilityArgs'] availability: The availability of mapping property.
          :param pulumi.Input['ConnectorMappingCompleteOperationArgs'] complete_operation: The operation after import is done.
          :param pulumi.Input['ConnectorMappingErrorManagementArgs'] error_management: The error management setting for the mapping.
          :param pulumi.Input['ConnectorMappingFormatArgs'] format: The format of mapping property.
          :param pulumi.Input[Sequence[pulumi.Input['ConnectorMappingStructureArgs']]] structure: Ingestion mapping information at property level.
          :param pulumi.Input[str] file_filter: The file filter for the mapping.
          :param pulumi.Input[str] folder_path: The folder path for the mapping.
          :param pulumi.Input[bool] has_header: If the file contains a header or not.
          """
          pulumi.set(__self__, "availability", availability)
          pulumi.set(__self__, "complete_operation", complete_operation)
          pulumi.set(__self__, "error_management", error_management)
          pulumi.set(__self__, "format", format)
          pulumi.set(__self__, "structure", structure)
          if file_filter is not None:
              pulumi.set(__self__, "file_filter", file_filter)
          if folder_path is not None:
              pulumi.set(__self__, "folder_path", folder_path)
          if has_header is not None:
              pulumi.set(__self__, "has_header", has_header)
  
      @property
      @pulumi.getter
      def availability(self) -> pulumi.Input['ConnectorMappingAvailabilityArgs']:
          """
          The availability of mapping property.
          """
          return pulumi.get(self, "availability")
  
      @availability.setter
      def availability(self, value: pulumi.Input['ConnectorMappingAvailabilityArgs']):
          pulumi.set(self, "availability", value)
  
      @property
      @pulumi.getter(name="completeOperation")
      def complete_operation(self) -> pulumi.Input['ConnectorMappingCompleteOperationArgs']:
          """
          The operation after import is done.
          """
          return pulumi.get(self, "complete_operation")
  
      @complete_operation.setter
      def complete_operation(self, value: pulumi.Input['ConnectorMappingCompleteOperationArgs']):
          pulumi.set(self, "complete_operation", value)
  
      @property
      @pulumi.getter(name="errorManagement")
      def error_management(self) -> pulumi.Input['ConnectorMappingErrorManagementArgs']:
          """
          The error management setting for the mapping.
          """
          return pulumi.get(self, "error_management")
  
      @error_management.setter
      def error_management(self, value: pulumi.Input['ConnectorMappingErrorManagementArgs']):
          pulumi.set(self, "error_management", value)
  
      @property
      @pulumi.getter
      def format(self) -> pulumi.Input['ConnectorMappingFormatArgs']:
          """
          The format of mapping property.
          """
          return pulumi.get(self, "format")
  
      @format.setter
      def format(self, value: pulumi.Input['ConnectorMappingFormatArgs']):
          pulumi.set(self, "format", value)
  
      @property
      @pulumi.getter
      def structure(self) -> pulumi.Input[Sequence[pulumi.Input['ConnectorMappingStructureArgs']]]:
          """
          Ingestion mapping information at property level.
          """
          return pulumi.get(self, "structure")
  
      @structure.setter
      def structure(self, value: pulumi.Input[Sequence[pulumi.Input['ConnectorMappingStructureArgs']]]):
          pulumi.set(self, "structure", value)
  
      @property
      @pulumi.getter(name="fileFilter")
      def file_filter(self) -> Optional[pulumi.Input[str]]:
          """
          The file filter for the mapping.
          """
          return pulumi.get(self, "file_filter")
  
      @file_filter.setter
      def file_filter(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "file_filter", value)
  
      @property
      @pulumi.getter(name="folderPath")
      def folder_path(self) -> Optional[pulumi.Input[str]]:
          """
          The folder path for the mapping.
          """
          return pulumi.get(self, "folder_path")
  
      @folder_path.setter
      def folder_path(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "folder_path", value)
  
      @property
      @pulumi.getter(name="hasHeader")
      def has_header(self) -> Optional[pulumi.Input[bool]]:
          """
          If the file contains a header or not.
          """
          return pulumi.get(self, "has_header")
  
      @has_header.setter
      def has_header(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "has_header", value)
  
  
  @pulumi.input_type
  class ConnectorMappingStructureArgs:
      def __init__(__self__, *,
                   column_name: pulumi.Input[str],
                   property_name: pulumi.Input[str],
                   custom_format_specifier: Optional[pulumi.Input[str]] = None,
                   is_encrypted: Optional[pulumi.Input[bool]] = None):
          """
          Connector mapping property structure.
          :param pulumi.Input[str] column_name: The column name of the import file.
          :param pulumi.Input[str] property_name: The property name of the mapping entity.
          :param pulumi.Input[str] custom_format_specifier: Custom format specifier for input parsing.
          :param pulumi.Input[bool] is_encrypted: Indicates if the column is encrypted.
          """
          pulumi.set(__self__, "column_name", column_name)
          pulumi.set(__self__, "property_name", property_name)
          if custom_format_specifier is not None:
              pulumi.set(__self__, "custom_format_specifier", custom_format_specifier)
          if is_encrypted is not None:
              pulumi.set(__self__, "is_encrypted", is_encrypted)
  
      @property
      @pulumi.getter(name="columnName")
      def column_name(self) -> pulumi.Input[str]:
          """
          The column name of the import file.
          """
          return pulumi.get(self, "column_name")
  
      @column_name.setter
      def column_name(self, value: pulumi.Input[str]):
          pulumi.set(self, "column_name", value)
  
      @property
      @pulumi.getter(name="propertyName")
      def property_name(self) -> pulumi.Input[str]:
          """
          The property name of the mapping entity.
          """
          return pulumi.get(self, "property_name")
  
      @property_name.setter
      def property_name(self, value: pulumi.Input[str]):
          pulumi.set(self, "property_name", value)
  
      @property
      @pulumi.getter(name="customFormatSpecifier")
      def custom_format_specifier(self) -> Optional[pulumi.Input[str]]:
          """
          Custom format specifier for input parsing.
          """
          return pulumi.get(self, "custom_format_specifier")
  
      @custom_format_specifier.setter
      def custom_format_specifier(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "custom_format_specifier", value)
  
      @property
      @pulumi.getter(name="isEncrypted")
      def is_encrypted(self) -> Optional[pulumi.Input[bool]]:
          """
          Indicates if the column is encrypted.
          """
          return pulumi.get(self, "is_encrypted")
  
      @is_encrypted.setter
      def is_encrypted(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "is_encrypted", value)
  
  
  @pulumi.input_type
  class HubBillingInfoFormatArgs:
      def __init__(__self__, *,
                   max_units: Optional[pulumi.Input[int]] = None,
                   min_units: Optional[pulumi.Input[int]] = None,
                   sku_name: Optional[pulumi.Input[str]] = None):
          """
          Hub billing info.
          :param pulumi.Input[int] max_units: The maximum number of units can be used.  One unit is 10,000 Profiles and 100,000 Interactions.
          :param pulumi.Input[int] min_units: The minimum number of units will be billed. One unit is 10,000 Profiles and 100,000 Interactions.
          :param pulumi.Input[str] sku_name: The sku name.
          """
          if max_units is not None:
              pulumi.set(__self__, "max_units", max_units)
          if min_units is not None:
              pulumi.set(__self__, "min_units", min_units)
          if sku_name is not None:
              pulumi.set(__self__, "sku_name", sku_name)
  
      @property
      @pulumi.getter(name="maxUnits")
      def max_units(self) -> Optional[pulumi.Input[int]]:
          """
          The maximum number of units can be used.  One unit is 10,000 Profiles and 100,000 Interactions.
          """
          return pulumi.get(self, "max_units")
  
      @max_units.setter
      def max_units(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "max_units", value)
  
      @property
      @pulumi.getter(name="minUnits")
      def min_units(self) -> Optional[pulumi.Input[int]]:
          """
          The minimum number of units will be billed. One unit is 10,000 Profiles and 100,000 Interactions.
          """
          return pulumi.get(self, "min_units")
  
      @min_units.setter
      def min_units(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "min_units", value)
  
      @property
      @pulumi.getter(name="skuName")
      def sku_name(self) -> Optional[pulumi.Input[str]]:
          """
          The sku name.
          """
          return pulumi.get(self, "sku_name")
  
      @sku_name.setter
      def sku_name(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "sku_name", value)
  
  
  @pulumi.input_type
  class KpiAliasArgs:
      def __init__(__self__, *,
                   alias_name: pulumi.Input[str],
                   expression: pulumi.Input[str]):
          """
          The KPI alias.
          :param pulumi.Input[str] alias_name: KPI alias name.
          :param pulumi.Input[str] expression: The expression.
          """
          pulumi.set(__self__, "alias_name", alias_name)
          pulumi.set(__self__, "expression", expression)
  
      @property
      @pulumi.getter(name="aliasName")
      def alias_name(self) -> pulumi.Input[str]:
          """
          KPI alias name.
          """
          return pulumi.get(self, "alias_name")
  
      @alias_name.setter
      def alias_name(self, value: pulumi.Input[str]):
          pulumi.set(self, "alias_name", value)
  
      @property
      @pulumi.getter
      def expression(self) -> pulumi.Input[str]:
          """
          The expression.
          """
          return pulumi.get(self, "expression")
  
      @expression.setter
      def expression(self, value: pulumi.Input[str]):
          pulumi.set(self, "expression", value)
  
  
  @pulumi.input_type
  class KpiExtractArgs:
      def __init__(__self__, *,
                   expression: pulumi.Input[str],
                   extract_name: pulumi.Input[str]):
          """
          The KPI extract.
          :param pulumi.Input[str] expression: The expression.
          :param pulumi.Input[str] extract_name: KPI extract name.
          """
          pulumi.set(__self__, "expression", expression)
          pulumi.set(__self__, "extract_name", extract_name)
  
      @property
      @pulumi.getter
      def expression(self) -> pulumi.Input[str]:
          """
          The expression.
          """
          return pulumi.get(self, "expression")
  
      @expression.setter
      def expression(self, value: pulumi.Input[str]):
          pulumi.set(self, "expression", value)
  
      @property
      @pulumi.getter(name="extractName")
      def extract_name(self) -> pulumi.Input[str]:
          """
          KPI extract name.
          """
          return pulumi.get(self, "extract_name")
  
      @extract_name.setter
      def extract_name(self, value: pulumi.Input[str]):
          pulumi.set(self, "extract_name", value)
  
  
  @pulumi.input_type
  class KpiThresholdsArgs:
      def __init__(__self__, *,
                   increasing_kpi: pulumi.Input[bool],
                   lower_limit: pulumi.Input[float],
                   upper_limit: pulumi.Input[float]):
          """
          Defines the KPI Threshold limits.
          :param pulumi.Input[bool] increasing_kpi: Whether or not the KPI is an increasing KPI.
          :param pulumi.Input[float] lower_limit: The lower threshold limit.
          :param pulumi.Input[float] upper_limit: The upper threshold limit.
          """
          pulumi.set(__self__, "increasing_kpi", increasing_kpi)
          pulumi.set(__self__, "lower_limit", lower_limit)
          pulumi.set(__self__, "upper_limit", upper_limit)
  
      @property
      @pulumi.getter(name="increasingKpi")
      def increasing_kpi(self) -> pulumi.Input[bool]:
          """
          Whether or not the KPI is an increasing KPI.
          """
          return pulumi.get(self, "increasing_kpi")
  
      @increasing_kpi.setter
      def increasing_kpi(self, value: pulumi.Input[bool]):
          pulumi.set(self, "increasing_kpi", value)
  
      @property
      @pulumi.getter(name="lowerLimit")
      def lower_limit(self) -> pulumi.Input[float]:
          """
          The lower threshold limit.
          """
          return pulumi.get(self, "lower_limit")
  
      @lower_limit.setter
      def lower_limit(self, value: pulumi.Input[float]):
          pulumi.set(self, "lower_limit", value)
  
      @property
      @pulumi.getter(name="upperLimit")
      def upper_limit(self) -> pulumi.Input[float]:
          """
          The upper threshold limit.
          """
          return pulumi.get(self, "upper_limit")
  
      @upper_limit.setter
      def upper_limit(self, value: pulumi.Input[float]):
          pulumi.set(self, "upper_limit", value)
  
  
  @pulumi.input_type
  class ParticipantProfilePropertyReferenceArgs:
      def __init__(__self__, *,
                   interaction_property_name: pulumi.Input[str],
                   profile_property_name: pulumi.Input[str]):
          """
          The participant profile property reference.
          :param pulumi.Input[str] interaction_property_name: The source interaction property that maps to the target profile property.
          :param pulumi.Input[str] profile_property_name: The target profile property that maps to the source interaction property.
          """
          pulumi.set(__self__, "interaction_property_name", interaction_property_name)
          pulumi.set(__self__, "profile_property_name", profile_property_name)
  
      @property
      @pulumi.getter(name="interactionPropertyName")
      def interaction_property_name(self) -> pulumi.Input[str]:
          """
          The source interaction property that maps to the target profile property.
          """
          return pulumi.get(self, "interaction_property_name")
  
      @interaction_property_name.setter
      def interaction_property_name(self, value: pulumi.Input[str]):
          pulumi.set(self, "interaction_property_name", value)
  
      @property
      @pulumi.getter(name="profilePropertyName")
      def profile_property_name(self) -> pulumi.Input[str]:
          """
          The target profile property that maps to the source interaction property.
          """
          return pulumi.get(self, "profile_property_name")
  
      @profile_property_name.setter
      def profile_property_name(self, value: pulumi.Input[str]):
          pulumi.set(self, "profile_property_name", value)
  
  
  @pulumi.input_type
  class ParticipantPropertyReferenceArgs:
      def __init__(__self__, *,
                   source_property_name: pulumi.Input[str],
                   target_property_name: pulumi.Input[str]):
          """
          The participant property reference.
          :param pulumi.Input[str] source_property_name: The source property that maps to the target property.
          :param pulumi.Input[str] target_property_name: The target property that maps to the source property.
          """
          pulumi.set(__self__, "source_property_name", source_property_name)
          pulumi.set(__self__, "target_property_name", target_property_name)
  
      @property
      @pulumi.getter(name="sourcePropertyName")
      def source_property_name(self) -> pulumi.Input[str]:
          """
          The source property that maps to the target property.
          """
          return pulumi.get(self, "source_property_name")
  
      @source_property_name.setter
      def source_property_name(self, value: pulumi.Input[str]):
          pulumi.set(self, "source_property_name", value)
  
      @property
      @pulumi.getter(name="targetPropertyName")
      def target_property_name(self) -> pulumi.Input[str]:
          """
          The target property that maps to the source property.
          """
          return pulumi.get(self, "target_property_name")
  
      @target_property_name.setter
      def target_property_name(self, value: pulumi.Input[str]):
          pulumi.set(self, "target_property_name", value)
  
  
  @pulumi.input_type
  class PredictionGradesArgs:
      def __init__(__self__, *,
                   grade_name: Optional[pulumi.Input[str]] = None,
                   max_score_threshold: Optional[pulumi.Input[int]] = None,
                   min_score_threshold: Optional[pulumi.Input[int]] = None):
          """
          The definition of a prediction grade.
          :param pulumi.Input[str] grade_name: Name of the grade.
          :param pulumi.Input[int] max_score_threshold: Maximum score threshold.
          :param pulumi.Input[int] min_score_threshold: Minimum score threshold.
          """
          if grade_name is not None:
              pulumi.set(__self__, "grade_name", grade_name)
          if max_score_threshold is not None:
              pulumi.set(__self__, "max_score_threshold", max_score_threshold)
          if min_score_threshold is not None:
              pulumi.set(__self__, "min_score_threshold", min_score_threshold)
  
      @property
      @pulumi.getter(name="gradeName")
      def grade_name(self) -> Optional[pulumi.Input[str]]:
          """
          Name of the grade.
          """
          return pulumi.get(self, "grade_name")
  
      @grade_name.setter
      def grade_name(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "grade_name", value)
  
      @property
      @pulumi.getter(name="maxScoreThreshold")
      def max_score_threshold(self) -> Optional[pulumi.Input[int]]:
          """
          Maximum score threshold.
          """
          return pulumi.get(self, "max_score_threshold")
  
      @max_score_threshold.setter
      def max_score_threshold(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "max_score_threshold", value)
  
      @property
      @pulumi.getter(name="minScoreThreshold")
      def min_score_threshold(self) -> Optional[pulumi.Input[int]]:
          """
          Minimum score threshold.
          """
          return pulumi.get(self, "min_score_threshold")
  
      @min_score_threshold.setter
      def min_score_threshold(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "min_score_threshold", value)
  
  
  @pulumi.input_type
  class PredictionMappingsArgs:
      def __init__(__self__, *,
                   grade: pulumi.Input[str],
                   reason: pulumi.Input[str],
                   score: pulumi.Input[str]):
          """
          Definition of the link mapping of prediction.
          :param pulumi.Input[str] grade: The grade of the link mapping.
          :param pulumi.Input[str] reason: The reason of the link mapping.
          :param pulumi.Input[str] score: The score of the link mapping.
          """
          pulumi.set(__self__, "grade", grade)
          pulumi.set(__self__, "reason", reason)
          pulumi.set(__self__, "score", score)
  
      @property
      @pulumi.getter
      def grade(self) -> pulumi.Input[str]:
          """
          The grade of the link mapping.
          """
          return pulumi.get(self, "grade")
  
      @grade.setter
      def grade(self, value: pulumi.Input[str]):
          pulumi.set(self, "grade", value)
  
      @property
      @pulumi.getter
      def reason(self) -> pulumi.Input[str]:
          """
          The reason of the link mapping.
          """
          return pulumi.get(self, "reason")
  
      @reason.setter
      def reason(self, value: pulumi.Input[str]):
          pulumi.set(self, "reason", value)
  
      @property
      @pulumi.getter
      def score(self) -> pulumi.Input[str]:
          """
          The score of the link mapping.
          """
          return pulumi.get(self, "score")
  
      @score.setter
      def score(self, value: pulumi.Input[str]):
          pulumi.set(self, "score", value)
  
  
  @pulumi.input_type
  class ProfileEnumValidValuesFormatArgs:
      def __init__(__self__, *,
                   localized_value_names: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
                   value: Optional[pulumi.Input[int]] = None):
          """
          Valid enum values in case of an enum property.
          :param pulumi.Input[Mapping[str, pulumi.Input[str]]] localized_value_names: Localized names of the enum member.
          :param pulumi.Input[int] value: The integer value of the enum member.
          """
          if localized_value_names is not None:
              pulumi.set(__self__, "localized_value_names", localized_value_names)
          if value is not None:
              pulumi.set(__self__, "value", value)
  
      @property
      @pulumi.getter(name="localizedValueNames")
      def localized_value_names(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
          """
          Localized names of the enum member.
          """
          return pulumi.get(self, "localized_value_names")
  
      @localized_value_names.setter
      def localized_value_names(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
          pulumi.set(self, "localized_value_names", value)
  
      @property
      @pulumi.getter
      def value(self) -> Optional[pulumi.Input[int]]:
          """
          The integer value of the enum member.
          """
          return pulumi.get(self, "value")
  
      @value.setter
      def value(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "value", value)
  
  
  @pulumi.input_type
  class PropertyDefinitionArgs:
      def __init__(__self__, *,
                   field_name: pulumi.Input[str],
                   field_type: pulumi.Input[str],
                   array_value_separator: Optional[pulumi.Input[str]] = None,
                   enum_valid_values: Optional[pulumi.Input[Sequence[pulumi.Input['ProfileEnumValidValuesFormatArgs']]]] = None,
                   is_array: Optional[pulumi.Input[bool]] = None,
                   is_available_in_graph: Optional[pulumi.Input[bool]] = None,
                   is_enum: Optional[pulumi.Input[bool]] = None,
                   is_flag_enum: Optional[pulumi.Input[bool]] = None,
                   is_image: Optional[pulumi.Input[bool]] = None,
                   is_localized_string: Optional[pulumi.Input[bool]] = None,
                   is_name: Optional[pulumi.Input[bool]] = None,
                   is_required: Optional[pulumi.Input[bool]] = None,
                   max_length: Optional[pulumi.Input[int]] = None,
                   property_id: Optional[pulumi.Input[str]] = None,
                   schema_item_prop_link: Optional[pulumi.Input[str]] = None):
          """
          Property definition.
          :param pulumi.Input[str] field_name: Name of the property.
          :param pulumi.Input[str] field_type: Type of the property.
          :param pulumi.Input[str] array_value_separator: Array value separator for properties with isArray set.
          :param pulumi.Input[Sequence[pulumi.Input['ProfileEnumValidValuesFormatArgs']]] enum_valid_values: Describes valid values for an enum property.
          :param pulumi.Input[bool] is_array: Indicates if the property is actually an array of the fieldType above on the data api.
          :param pulumi.Input[bool] is_available_in_graph: Whether property is available in graph or not.
          :param pulumi.Input[bool] is_enum: Indicates if the property is an enum.
          :param pulumi.Input[bool] is_flag_enum: Indicates if the property is an flag enum.
          :param pulumi.Input[bool] is_image: Whether the property is an Image.
          :param pulumi.Input[bool] is_localized_string: Whether the property is a localized string.
          :param pulumi.Input[bool] is_name: Whether the property is a name or a part of name.
          :param pulumi.Input[bool] is_required: Whether property value is required on instances, IsRequired field only for Interaction. Profile Instance will not check for required field.
          :param pulumi.Input[int] max_length: Max length of string. Used only if type is string.
          :param pulumi.Input[str] property_id: The ID associated with the property.
          :param pulumi.Input[str] schema_item_prop_link: URL encoded schema.org item prop link for the property.
          """
          pulumi.set(__self__, "field_name", field_name)
          pulumi.set(__self__, "field_type", field_type)
          if array_value_separator is not None:
              pulumi.set(__self__, "array_value_separator", array_value_separator)
          if enum_valid_values is not None:
              pulumi.set(__self__, "enum_valid_values", enum_valid_values)
          if is_array is not None:
              pulumi.set(__self__, "is_array", is_array)
          if is_available_in_graph is not None:
              pulumi.set(__self__, "is_available_in_graph", is_available_in_graph)
          if is_enum is not None:
              pulumi.set(__self__, "is_enum", is_enum)
          if is_flag_enum is not None:
              pulumi.set(__self__, "is_flag_enum", is_flag_enum)
          if is_image is not None:
              pulumi.set(__self__, "is_image", is_image)
          if is_localized_string is not None:
              pulumi.set(__self__, "is_localized_string", is_localized_string)
          if is_name is not None:
              pulumi.set(__self__, "is_name", is_name)
          if is_required is not None:
              pulumi.set(__self__, "is_required", is_required)
          if max_length is not None:
              pulumi.set(__self__, "max_length", max_length)
          if property_id is not None:
              pulumi.set(__self__, "property_id", property_id)
          if schema_item_prop_link is not None:
              pulumi.set(__self__, "schema_item_prop_link", schema_item_prop_link)
  
      @property
      @pulumi.getter(name="fieldName")
      def field_name(self) -> pulumi.Input[str]:
          """
          Name of the property.
          """
          return pulumi.get(self, "field_name")
  
      @field_name.setter
      def field_name(self, value: pulumi.Input[str]):
          pulumi.set(self, "field_name", value)
  
      @property
      @pulumi.getter(name="fieldType")
      def field_type(self) -> pulumi.Input[str]:
          """
          Type of the property.
          """
          return pulumi.get(self, "field_type")
  
      @field_type.setter
      def field_type(self, value: pulumi.Input[str]):
          pulumi.set(self, "field_type", value)
  
      @property
      @pulumi.getter(name="arrayValueSeparator")
      def array_value_separator(self) -> Optional[pulumi.Input[str]]:
          """
          Array value separator for properties with isArray set.
          """
          return pulumi.get(self, "array_value_separator")
  
      @array_value_separator.setter
      def array_value_separator(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "array_value_separator", value)
  
      @property
      @pulumi.getter(name="enumValidValues")
      def enum_valid_values(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ProfileEnumValidValuesFormatArgs']]]]:
          """
          Describes valid values for an enum property.
          """
          return pulumi.get(self, "enum_valid_values")
  
      @enum_valid_values.setter
      def enum_valid_values(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ProfileEnumValidValuesFormatArgs']]]]):
          pulumi.set(self, "enum_valid_values", value)
  
      @property
      @pulumi.getter(name="isArray")
      def is_array(self) -> Optional[pulumi.Input[bool]]:
          """
          Indicates if the property is actually an array of the fieldType above on the data api.
          """
          return pulumi.get(self, "is_array")
  
      @is_array.setter
      def is_array(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "is_array", value)
  
      @property
      @pulumi.getter(name="isAvailableInGraph")
      def is_available_in_graph(self) -> Optional[pulumi.Input[bool]]:
          """
          Whether property is available in graph or not.
          """
          return pulumi.get(self, "is_available_in_graph")
  
      @is_available_in_graph.setter
      def is_available_in_graph(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "is_available_in_graph", value)
  
      @property
      @pulumi.getter(name="isEnum")
      def is_enum(self) -> Optional[pulumi.Input[bool]]:
          """
          Indicates if the property is an enum.
          """
          return pulumi.get(self, "is_enum")
  
      @is_enum.setter
      def is_enum(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "is_enum", value)
  
      @property
      @pulumi.getter(name="isFlagEnum")
      def is_flag_enum(self) -> Optional[pulumi.Input[bool]]:
          """
          Indicates if the property is an flag enum.
          """
          return pulumi.get(self, "is_flag_enum")
  
      @is_flag_enum.setter
      def is_flag_enum(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "is_flag_enum", value)
  
      @property
      @pulumi.getter(name="isImage")
      def is_image(self) -> Optional[pulumi.Input[bool]]:
          """
          Whether the property is an Image.
          """
          return pulumi.get(self, "is_image")
  
      @is_image.setter
      def is_image(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "is_image", value)
  
      @property
      @pulumi.getter(name="isLocalizedString")
      def is_localized_string(self) -> Optional[pulumi.Input[bool]]:
          """
          Whether the property is a localized string.
          """
          return pulumi.get(self, "is_localized_string")
  
      @is_localized_string.setter
      def is_localized_string(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "is_localized_string", value)
  
      @property
      @pulumi.getter(name="isName")
      def is_name(self) -> Optional[pulumi.Input[bool]]:
          """
          Whether the property is a name or a part of name.
          """
          return pulumi.get(self, "is_name")
  
      @is_name.setter
      def is_name(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "is_name", value)
  
      @property
      @pulumi.getter(name="isRequired")
      def is_required(self) -> Optional[pulumi.Input[bool]]:
          """
          Whether property value is required on instances, IsRequired field only for Interaction. Profile Instance will not check for required field.
          """
          return pulumi.get(self, "is_required")
  
      @is_required.setter
      def is_required(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "is_required", value)
  
      @property
      @pulumi.getter(name="maxLength")
      def max_length(self) -> Optional[pulumi.Input[int]]:
          """
          Max length of string. Used only if type is string.
          """
          return pulumi.get(self, "max_length")
  
      @max_length.setter
      def max_length(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "max_length", value)
  
      @property
      @pulumi.getter(name="propertyId")
      def property_id(self) -> Optional[pulumi.Input[str]]:
          """
          The ID associated with the property.
          """
          return pulumi.get(self, "property_id")
  
      @property_id.setter
      def property_id(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "property_id", value)
  
      @property
      @pulumi.getter(name="schemaItemPropLink")
      def schema_item_prop_link(self) -> Optional[pulumi.Input[str]]:
          """
          URL encoded schema.org item prop link for the property.
          """
          return pulumi.get(self, "schema_item_prop_link")
  
      @schema_item_prop_link.setter
      def schema_item_prop_link(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "schema_item_prop_link", value)
  
  
  @pulumi.input_type
  class RelationshipLinkFieldMappingArgs:
      def __init__(__self__, *,
                   interaction_field_name: pulumi.Input[str],
                   relationship_field_name: pulumi.Input[str],
                   link_type: Optional[pulumi.Input[str]] = None):
          """
          The fields mapping for Relationships.
          :param pulumi.Input[str] interaction_field_name: The field name on the Interaction Type.
          :param pulumi.Input[str] relationship_field_name: The field name on the Relationship metadata.
          :param pulumi.Input[str] link_type: Link type.
          """
          pulumi.set(__self__, "interaction_field_name", interaction_field_name)
          pulumi.set(__self__, "relationship_field_name", relationship_field_name)
          if link_type is not None:
              pulumi.set(__self__, "link_type", link_type)
  
      @property
      @pulumi.getter(name="interactionFieldName")
      def interaction_field_name(self) -> pulumi.Input[str]:
          """
          The field name on the Interaction Type.
          """
          return pulumi.get(self, "interaction_field_name")
  
      @interaction_field_name.setter
      def interaction_field_name(self, value: pulumi.Input[str]):
          pulumi.set(self, "interaction_field_name", value)
  
      @property
      @pulumi.getter(name="relationshipFieldName")
      def relationship_field_name(self) -> pulumi.Input[str]:
          """
          The field name on the Relationship metadata.
          """
          return pulumi.get(self, "relationship_field_name")
  
      @relationship_field_name.setter
      def relationship_field_name(self, value: pulumi.Input[str]):
          pulumi.set(self, "relationship_field_name", value)
  
      @property
      @pulumi.getter(name="linkType")
      def link_type(self) -> Optional[pulumi.Input[str]]:
          """
          Link type.
          """
          return pulumi.get(self, "link_type")
  
      @link_type.setter
      def link_type(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "link_type", value)
  
  
  @pulumi.input_type
  class RelationshipTypeFieldMappingArgs:
      def __init__(__self__, *,
                   profile_field_name: pulumi.Input[str],
                   related_profile_key_property: pulumi.Input[str]):
          """
          Map a field of profile to its corresponding StrongId in Related Profile.
          :param pulumi.Input[str] profile_field_name: Specifies the fieldName in profile.
          :param pulumi.Input[str] related_profile_key_property: Specifies the KeyProperty (from StrongId) of the related profile.
          """
          pulumi.set(__self__, "profile_field_name", profile_field_name)
          pulumi.set(__self__, "related_profile_key_property", related_profile_key_property)
  
      @property
      @pulumi.getter(name="profileFieldName")
      def profile_field_name(self) -> pulumi.Input[str]:
          """
          Specifies the fieldName in profile.
          """
          return pulumi.get(self, "profile_field_name")
  
      @profile_field_name.setter
      def profile_field_name(self, value: pulumi.Input[str]):
          pulumi.set(self, "profile_field_name", value)
  
      @property
      @pulumi.getter(name="relatedProfileKeyProperty")
      def related_profile_key_property(self) -> pulumi.Input[str]:
          """
          Specifies the KeyProperty (from StrongId) of the related profile.
          """
          return pulumi.get(self, "related_profile_key_property")
  
      @related_profile_key_property.setter
      def related_profile_key_property(self, value: pulumi.Input[str]):
          pulumi.set(self, "related_profile_key_property", value)
  
  
  @pulumi.input_type
  class RelationshipTypeMappingArgs:
      def __init__(__self__, *,
                   field_mappings: pulumi.Input[Sequence[pulumi.Input['RelationshipTypeFieldMappingArgs']]]):
          """
          Maps fields in Profile to their corresponding StrongIds in Related Profile.
          :param pulumi.Input[Sequence[pulumi.Input['RelationshipTypeFieldMappingArgs']]] field_mappings: Maps a profile property with the StrongId of related profile. This is an array to support StrongIds that are composite key as well.
          """
          pulumi.set(__self__, "field_mappings", field_mappings)
  
      @property
      @pulumi.getter(name="fieldMappings")
      def field_mappings(self) -> pulumi.Input[Sequence[pulumi.Input['RelationshipTypeFieldMappingArgs']]]:
          """
          Maps a profile property with the StrongId of related profile. This is an array to support StrongIds that are composite key as well.
          """
          return pulumi.get(self, "field_mappings")
  
      @field_mappings.setter
      def field_mappings(self, value: pulumi.Input[Sequence[pulumi.Input['RelationshipTypeFieldMappingArgs']]]):
          pulumi.set(self, "field_mappings", value)
  
  
  @pulumi.input_type
  class ResourceSetDescriptionArgs:
      def __init__(__self__, *,
                   elements: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                   exceptions: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
          """
          The resource set description.
          :param pulumi.Input[Sequence[pulumi.Input[str]]] elements: The elements included in the set.
          :param pulumi.Input[Sequence[pulumi.Input[str]]] exceptions: The elements that are not included in the set, in case elements contains '*' indicating 'all'.
          """
          if elements is not None:
              pulumi.set(__self__, "elements", elements)
          if exceptions is not None:
              pulumi.set(__self__, "exceptions", exceptions)
  
      @property
      @pulumi.getter
      def elements(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
          """
          The elements included in the set.
          """
          return pulumi.get(self, "elements")
  
      @elements.setter
      def elements(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
          pulumi.set(self, "elements", value)
  
      @property
      @pulumi.getter
      def exceptions(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
          """
          The elements that are not included in the set, in case elements contains '*' indicating 'all'.
          """
          return pulumi.get(self, "exceptions")
  
      @exceptions.setter
      def exceptions(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
          pulumi.set(self, "exceptions", value)
  
  
  @pulumi.input_type
  class StrongIdArgs:
      def __init__(__self__, *,
                   key_property_names: pulumi.Input[Sequence[pulumi.Input[str]]],
                   strong_id_name: pulumi.Input[str],
                   description: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
                   display_name: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None):
          """
          Property/Properties which represent a unique ID.
          :param pulumi.Input[Sequence[pulumi.Input[str]]] key_property_names: The properties which make up the unique ID.
          :param pulumi.Input[str] strong_id_name: The Name identifying the strong ID.
          :param pulumi.Input[Mapping[str, pulumi.Input[str]]] description: Localized descriptions.
          :param pulumi.Input[Mapping[str, pulumi.Input[str]]] display_name: Localized display name.
          """
          pulumi.set(__self__, "key_property_names", key_property_names)
          pulumi.set(__self__, "strong_id_name", strong_id_name)
          if description is not None:
              pulumi.set(__self__, "description", description)
          if display_name is not None:
              pulumi.set(__self__, "display_name", display_name)
  
      @property
      @pulumi.getter(name="keyPropertyNames")
      def key_property_names(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
          """
          The properties which make up the unique ID.
          """
          return pulumi.get(self, "key_property_names")
  
      @key_property_names.setter
      def key_property_names(self, value: pulumi.Input[Sequence[pulumi.Input[str]]]):
          pulumi.set(self, "key_property_names", value)
  
      @property
      @pulumi.getter(name="strongIdName")
      def strong_id_name(self) -> pulumi.Input[str]:
          """
          The Name identifying the strong ID.
          """
          return pulumi.get(self, "strong_id_name")
  
      @strong_id_name.setter
      def strong_id_name(self, value: pulumi.Input[str]):
          pulumi.set(self, "strong_id_name", value)
  
      @property
      @pulumi.getter
      def description(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
          """
          Localized descriptions.
          """
          return pulumi.get(self, "description")
  
      @description.setter
      def description(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
          pulumi.set(self, "description", value)
  
      @property
      @pulumi.getter(name="displayName")
      def display_name(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
          """
          Localized display name.
          """
          return pulumi.get(self, "display_name")
  
      @display_name.setter
      def display_name(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
          pulumi.set(self, "display_name", value)
  
  
  @pulumi.input_type
  class TypePropertiesMappingArgs:
      def __init__(__self__, *,
                   source_property_name: pulumi.Input[str],
                   target_property_name: pulumi.Input[str],
                   link_type: Optional[pulumi.Input[str]] = None):
          """
          Metadata for a Link's property mapping.
          :param pulumi.Input[str] source_property_name:  Property name on the source Entity Type.
          :param pulumi.Input[str] target_property_name: Property name on the target Entity Type.
          :param pulumi.Input[str] link_type: Link type.
          """
          pulumi.set(__self__, "source_property_name", source_property_name)
          pulumi.set(__self__, "target_property_name", target_property_name)
          if link_type is not None:
              pulumi.set(__self__, "link_type", link_type)
  
      @property
      @pulumi.getter(name="sourcePropertyName")
      def source_property_name(self) -> pulumi.Input[str]:
          """
           Property name on the source Entity Type.
          """
          return pulumi.get(self, "source_property_name")
  
      @source_property_name.setter
      def source_property_name(self, value: pulumi.Input[str]):
          pulumi.set(self, "source_property_name", value)
  
      @property
      @pulumi.getter(name="targetPropertyName")
      def target_property_name(self) -> pulumi.Input[str]:
          """
          Property name on the target Entity Type.
          """
          return pulumi.get(self, "target_property_name")
  
      @target_property_name.setter
      def target_property_name(self, value: pulumi.Input[str]):
          pulumi.set(self, "target_property_name", value)
  
      @property
      @pulumi.getter(name="linkType")
      def link_type(self) -> Optional[pulumi.Input[str]]:
          """
          Link type.
          """
          return pulumi.get(self, "link_type")
  
      @link_type.setter
      def link_type(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "link_type", value)
  
  
  