# 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, overload
from .. import _utilities
from . import outputs

__all__ = [
    'ApplicationSettingsCampaignHook',
    'ApplicationSettingsLimits',
    'ApplicationSettingsQuietTime',
    'CampaignCampaignEmailMessage',
    'CampaignCampaignEventFilter',
    'CampaignCampaignHook',
    'CampaignCampaignSmsMessage',
    'CampaignEventDimensions',
    'CampaignLimits',
    'CampaignMessage',
    'CampaignMessageConfiguration',
    'CampaignQuietTime',
    'CampaignSchedule',
    'CampaignSetDimension',
    'CampaignWriteTreatmentResource',
    'PushTemplateAPNSPushNotificationTemplate',
    'PushTemplateAndroidPushNotificationTemplate',
    'PushTemplateDefaultPushNotificationTemplate',
    'SegmentBehavior',
    'SegmentCoordinates',
    'SegmentDemographic',
    'SegmentGPSPoint',
    'SegmentGroups',
    'SegmentLocation',
    'SegmentRecency',
    'SegmentSegmentDimensions',
    'SegmentSegmentGroups',
    'SegmentSetDimension',
    'SegmentSourceSegments',
]

@pulumi.output_type
class ApplicationSettingsCampaignHook(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "lambdaFunctionName":
            suggest = "lambda_function_name"
        elif key == "webUrl":
            suggest = "web_url"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ApplicationSettingsCampaignHook. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ApplicationSettingsCampaignHook.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ApplicationSettingsCampaignHook.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 lambda_function_name: Optional[str] = None,
                 mode: Optional[str] = None,
                 web_url: Optional[str] = None):
        if lambda_function_name is not None:
            pulumi.set(__self__, "lambda_function_name", lambda_function_name)
        if mode is not None:
            pulumi.set(__self__, "mode", mode)
        if web_url is not None:
            pulumi.set(__self__, "web_url", web_url)

    @property
    @pulumi.getter(name="lambdaFunctionName")
    def lambda_function_name(self) -> Optional[str]:
        return pulumi.get(self, "lambda_function_name")

    @property
    @pulumi.getter
    def mode(self) -> Optional[str]:
        return pulumi.get(self, "mode")

    @property
    @pulumi.getter(name="webUrl")
    def web_url(self) -> Optional[str]:
        return pulumi.get(self, "web_url")


@pulumi.output_type
class ApplicationSettingsLimits(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "maximumDuration":
            suggest = "maximum_duration"
        elif key == "messagesPerSecond":
            suggest = "messages_per_second"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ApplicationSettingsLimits. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ApplicationSettingsLimits.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ApplicationSettingsLimits.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 daily: Optional[int] = None,
                 maximum_duration: Optional[int] = None,
                 messages_per_second: Optional[int] = None,
                 total: Optional[int] = None):
        if daily is not None:
            pulumi.set(__self__, "daily", daily)
        if maximum_duration is not None:
            pulumi.set(__self__, "maximum_duration", maximum_duration)
        if messages_per_second is not None:
            pulumi.set(__self__, "messages_per_second", messages_per_second)
        if total is not None:
            pulumi.set(__self__, "total", total)

    @property
    @pulumi.getter
    def daily(self) -> Optional[int]:
        return pulumi.get(self, "daily")

    @property
    @pulumi.getter(name="maximumDuration")
    def maximum_duration(self) -> Optional[int]:
        return pulumi.get(self, "maximum_duration")

    @property
    @pulumi.getter(name="messagesPerSecond")
    def messages_per_second(self) -> Optional[int]:
        return pulumi.get(self, "messages_per_second")

    @property
    @pulumi.getter
    def total(self) -> Optional[int]:
        return pulumi.get(self, "total")


@pulumi.output_type
class ApplicationSettingsQuietTime(dict):
    def __init__(__self__, *,
                 end: str,
                 start: str):
        pulumi.set(__self__, "end", end)
        pulumi.set(__self__, "start", start)

    @property
    @pulumi.getter
    def end(self) -> str:
        return pulumi.get(self, "end")

    @property
    @pulumi.getter
    def start(self) -> str:
        return pulumi.get(self, "start")


@pulumi.output_type
class CampaignCampaignEmailMessage(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "fromAddress":
            suggest = "from_address"
        elif key == "htmlBody":
            suggest = "html_body"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in CampaignCampaignEmailMessage. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        CampaignCampaignEmailMessage.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        CampaignCampaignEmailMessage.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 body: Optional[str] = None,
                 from_address: Optional[str] = None,
                 html_body: Optional[str] = None,
                 title: Optional[str] = None):
        if body is not None:
            pulumi.set(__self__, "body", body)
        if from_address is not None:
            pulumi.set(__self__, "from_address", from_address)
        if html_body is not None:
            pulumi.set(__self__, "html_body", html_body)
        if title is not None:
            pulumi.set(__self__, "title", title)

    @property
    @pulumi.getter
    def body(self) -> Optional[str]:
        return pulumi.get(self, "body")

    @property
    @pulumi.getter(name="fromAddress")
    def from_address(self) -> Optional[str]:
        return pulumi.get(self, "from_address")

    @property
    @pulumi.getter(name="htmlBody")
    def html_body(self) -> Optional[str]:
        return pulumi.get(self, "html_body")

    @property
    @pulumi.getter
    def title(self) -> Optional[str]:
        return pulumi.get(self, "title")


@pulumi.output_type
class CampaignCampaignEventFilter(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "filterType":
            suggest = "filter_type"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in CampaignCampaignEventFilter. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        CampaignCampaignEventFilter.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        CampaignCampaignEventFilter.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 dimensions: Optional['outputs.CampaignEventDimensions'] = None,
                 filter_type: Optional[str] = None):
        if dimensions is not None:
            pulumi.set(__self__, "dimensions", dimensions)
        if filter_type is not None:
            pulumi.set(__self__, "filter_type", filter_type)

    @property
    @pulumi.getter
    def dimensions(self) -> Optional['outputs.CampaignEventDimensions']:
        return pulumi.get(self, "dimensions")

    @property
    @pulumi.getter(name="filterType")
    def filter_type(self) -> Optional[str]:
        return pulumi.get(self, "filter_type")


@pulumi.output_type
class CampaignCampaignHook(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "lambdaFunctionName":
            suggest = "lambda_function_name"
        elif key == "webUrl":
            suggest = "web_url"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in CampaignCampaignHook. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        CampaignCampaignHook.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        CampaignCampaignHook.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 lambda_function_name: Optional[str] = None,
                 mode: Optional[str] = None,
                 web_url: Optional[str] = None):
        if lambda_function_name is not None:
            pulumi.set(__self__, "lambda_function_name", lambda_function_name)
        if mode is not None:
            pulumi.set(__self__, "mode", mode)
        if web_url is not None:
            pulumi.set(__self__, "web_url", web_url)

    @property
    @pulumi.getter(name="lambdaFunctionName")
    def lambda_function_name(self) -> Optional[str]:
        return pulumi.get(self, "lambda_function_name")

    @property
    @pulumi.getter
    def mode(self) -> Optional[str]:
        return pulumi.get(self, "mode")

    @property
    @pulumi.getter(name="webUrl")
    def web_url(self) -> Optional[str]:
        return pulumi.get(self, "web_url")


@pulumi.output_type
class CampaignCampaignSmsMessage(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "entityId":
            suggest = "entity_id"
        elif key == "messageType":
            suggest = "message_type"
        elif key == "originationNumber":
            suggest = "origination_number"
        elif key == "senderId":
            suggest = "sender_id"
        elif key == "templateId":
            suggest = "template_id"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in CampaignCampaignSmsMessage. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        CampaignCampaignSmsMessage.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        CampaignCampaignSmsMessage.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 body: Optional[str] = None,
                 entity_id: Optional[str] = None,
                 message_type: Optional[str] = None,
                 origination_number: Optional[str] = None,
                 sender_id: Optional[str] = None,
                 template_id: Optional[str] = None):
        if body is not None:
            pulumi.set(__self__, "body", body)
        if entity_id is not None:
            pulumi.set(__self__, "entity_id", entity_id)
        if message_type is not None:
            pulumi.set(__self__, "message_type", message_type)
        if origination_number is not None:
            pulumi.set(__self__, "origination_number", origination_number)
        if sender_id is not None:
            pulumi.set(__self__, "sender_id", sender_id)
        if template_id is not None:
            pulumi.set(__self__, "template_id", template_id)

    @property
    @pulumi.getter
    def body(self) -> Optional[str]:
        return pulumi.get(self, "body")

    @property
    @pulumi.getter(name="entityId")
    def entity_id(self) -> Optional[str]:
        return pulumi.get(self, "entity_id")

    @property
    @pulumi.getter(name="messageType")
    def message_type(self) -> Optional[str]:
        return pulumi.get(self, "message_type")

    @property
    @pulumi.getter(name="originationNumber")
    def origination_number(self) -> Optional[str]:
        return pulumi.get(self, "origination_number")

    @property
    @pulumi.getter(name="senderId")
    def sender_id(self) -> Optional[str]:
        return pulumi.get(self, "sender_id")

    @property
    @pulumi.getter(name="templateId")
    def template_id(self) -> Optional[str]:
        return pulumi.get(self, "template_id")


@pulumi.output_type
class CampaignEventDimensions(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "eventType":
            suggest = "event_type"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in CampaignEventDimensions. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        CampaignEventDimensions.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        CampaignEventDimensions.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 attributes: Optional[Any] = None,
                 event_type: Optional['outputs.CampaignSetDimension'] = None,
                 metrics: Optional[Any] = None):
        if attributes is not None:
            pulumi.set(__self__, "attributes", attributes)
        if event_type is not None:
            pulumi.set(__self__, "event_type", event_type)
        if metrics is not None:
            pulumi.set(__self__, "metrics", metrics)

    @property
    @pulumi.getter
    def attributes(self) -> Optional[Any]:
        return pulumi.get(self, "attributes")

    @property
    @pulumi.getter(name="eventType")
    def event_type(self) -> Optional['outputs.CampaignSetDimension']:
        return pulumi.get(self, "event_type")

    @property
    @pulumi.getter
    def metrics(self) -> Optional[Any]:
        return pulumi.get(self, "metrics")


@pulumi.output_type
class CampaignLimits(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "maximumDuration":
            suggest = "maximum_duration"
        elif key == "messagesPerSecond":
            suggest = "messages_per_second"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in CampaignLimits. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        CampaignLimits.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        CampaignLimits.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 daily: Optional[int] = None,
                 maximum_duration: Optional[int] = None,
                 messages_per_second: Optional[int] = None,
                 total: Optional[int] = None):
        if daily is not None:
            pulumi.set(__self__, "daily", daily)
        if maximum_duration is not None:
            pulumi.set(__self__, "maximum_duration", maximum_duration)
        if messages_per_second is not None:
            pulumi.set(__self__, "messages_per_second", messages_per_second)
        if total is not None:
            pulumi.set(__self__, "total", total)

    @property
    @pulumi.getter
    def daily(self) -> Optional[int]:
        return pulumi.get(self, "daily")

    @property
    @pulumi.getter(name="maximumDuration")
    def maximum_duration(self) -> Optional[int]:
        return pulumi.get(self, "maximum_duration")

    @property
    @pulumi.getter(name="messagesPerSecond")
    def messages_per_second(self) -> Optional[int]:
        return pulumi.get(self, "messages_per_second")

    @property
    @pulumi.getter
    def total(self) -> Optional[int]:
        return pulumi.get(self, "total")


@pulumi.output_type
class CampaignMessage(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "imageIconUrl":
            suggest = "image_icon_url"
        elif key == "imageSmallIconUrl":
            suggest = "image_small_icon_url"
        elif key == "imageUrl":
            suggest = "image_url"
        elif key == "jsonBody":
            suggest = "json_body"
        elif key == "mediaUrl":
            suggest = "media_url"
        elif key == "rawContent":
            suggest = "raw_content"
        elif key == "silentPush":
            suggest = "silent_push"
        elif key == "timeToLive":
            suggest = "time_to_live"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in CampaignMessage. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        CampaignMessage.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        CampaignMessage.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 action: Optional[str] = None,
                 body: Optional[str] = None,
                 image_icon_url: Optional[str] = None,
                 image_small_icon_url: Optional[str] = None,
                 image_url: Optional[str] = None,
                 json_body: Optional[str] = None,
                 media_url: Optional[str] = None,
                 raw_content: Optional[str] = None,
                 silent_push: Optional[bool] = None,
                 time_to_live: Optional[int] = None,
                 title: Optional[str] = None,
                 url: Optional[str] = None):
        if action is not None:
            pulumi.set(__self__, "action", action)
        if body is not None:
            pulumi.set(__self__, "body", body)
        if image_icon_url is not None:
            pulumi.set(__self__, "image_icon_url", image_icon_url)
        if image_small_icon_url is not None:
            pulumi.set(__self__, "image_small_icon_url", image_small_icon_url)
        if image_url is not None:
            pulumi.set(__self__, "image_url", image_url)
        if json_body is not None:
            pulumi.set(__self__, "json_body", json_body)
        if media_url is not None:
            pulumi.set(__self__, "media_url", media_url)
        if raw_content is not None:
            pulumi.set(__self__, "raw_content", raw_content)
        if silent_push is not None:
            pulumi.set(__self__, "silent_push", silent_push)
        if time_to_live is not None:
            pulumi.set(__self__, "time_to_live", time_to_live)
        if title is not None:
            pulumi.set(__self__, "title", title)
        if url is not None:
            pulumi.set(__self__, "url", url)

    @property
    @pulumi.getter
    def action(self) -> Optional[str]:
        return pulumi.get(self, "action")

    @property
    @pulumi.getter
    def body(self) -> Optional[str]:
        return pulumi.get(self, "body")

    @property
    @pulumi.getter(name="imageIconUrl")
    def image_icon_url(self) -> Optional[str]:
        return pulumi.get(self, "image_icon_url")

    @property
    @pulumi.getter(name="imageSmallIconUrl")
    def image_small_icon_url(self) -> Optional[str]:
        return pulumi.get(self, "image_small_icon_url")

    @property
    @pulumi.getter(name="imageUrl")
    def image_url(self) -> Optional[str]:
        return pulumi.get(self, "image_url")

    @property
    @pulumi.getter(name="jsonBody")
    def json_body(self) -> Optional[str]:
        return pulumi.get(self, "json_body")

    @property
    @pulumi.getter(name="mediaUrl")
    def media_url(self) -> Optional[str]:
        return pulumi.get(self, "media_url")

    @property
    @pulumi.getter(name="rawContent")
    def raw_content(self) -> Optional[str]:
        return pulumi.get(self, "raw_content")

    @property
    @pulumi.getter(name="silentPush")
    def silent_push(self) -> Optional[bool]:
        return pulumi.get(self, "silent_push")

    @property
    @pulumi.getter(name="timeToLive")
    def time_to_live(self) -> Optional[int]:
        return pulumi.get(self, "time_to_live")

    @property
    @pulumi.getter
    def title(self) -> Optional[str]:
        return pulumi.get(self, "title")

    @property
    @pulumi.getter
    def url(self) -> Optional[str]:
        return pulumi.get(self, "url")


@pulumi.output_type
class CampaignMessageConfiguration(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "aDMMessage":
            suggest = "a_dm_message"
        elif key == "aPNSMessage":
            suggest = "a_pns_message"
        elif key == "baiduMessage":
            suggest = "baidu_message"
        elif key == "defaultMessage":
            suggest = "default_message"
        elif key == "emailMessage":
            suggest = "email_message"
        elif key == "gCMMessage":
            suggest = "g_cm_message"
        elif key == "sMSMessage":
            suggest = "s_ms_message"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in CampaignMessageConfiguration. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        CampaignMessageConfiguration.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        CampaignMessageConfiguration.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 a_dm_message: Optional['outputs.CampaignMessage'] = None,
                 a_pns_message: Optional['outputs.CampaignMessage'] = None,
                 baidu_message: Optional['outputs.CampaignMessage'] = None,
                 default_message: Optional['outputs.CampaignMessage'] = None,
                 email_message: Optional['outputs.CampaignCampaignEmailMessage'] = None,
                 g_cm_message: Optional['outputs.CampaignMessage'] = None,
                 s_ms_message: Optional['outputs.CampaignCampaignSmsMessage'] = None):
        if a_dm_message is not None:
            pulumi.set(__self__, "a_dm_message", a_dm_message)
        if a_pns_message is not None:
            pulumi.set(__self__, "a_pns_message", a_pns_message)
        if baidu_message is not None:
            pulumi.set(__self__, "baidu_message", baidu_message)
        if default_message is not None:
            pulumi.set(__self__, "default_message", default_message)
        if email_message is not None:
            pulumi.set(__self__, "email_message", email_message)
        if g_cm_message is not None:
            pulumi.set(__self__, "g_cm_message", g_cm_message)
        if s_ms_message is not None:
            pulumi.set(__self__, "s_ms_message", s_ms_message)

    @property
    @pulumi.getter(name="aDMMessage")
    def a_dm_message(self) -> Optional['outputs.CampaignMessage']:
        return pulumi.get(self, "a_dm_message")

    @property
    @pulumi.getter(name="aPNSMessage")
    def a_pns_message(self) -> Optional['outputs.CampaignMessage']:
        return pulumi.get(self, "a_pns_message")

    @property
    @pulumi.getter(name="baiduMessage")
    def baidu_message(self) -> Optional['outputs.CampaignMessage']:
        return pulumi.get(self, "baidu_message")

    @property
    @pulumi.getter(name="defaultMessage")
    def default_message(self) -> Optional['outputs.CampaignMessage']:
        return pulumi.get(self, "default_message")

    @property
    @pulumi.getter(name="emailMessage")
    def email_message(self) -> Optional['outputs.CampaignCampaignEmailMessage']:
        return pulumi.get(self, "email_message")

    @property
    @pulumi.getter(name="gCMMessage")
    def g_cm_message(self) -> Optional['outputs.CampaignMessage']:
        return pulumi.get(self, "g_cm_message")

    @property
    @pulumi.getter(name="sMSMessage")
    def s_ms_message(self) -> Optional['outputs.CampaignCampaignSmsMessage']:
        return pulumi.get(self, "s_ms_message")


@pulumi.output_type
class CampaignQuietTime(dict):
    def __init__(__self__, *,
                 end: str,
                 start: str):
        pulumi.set(__self__, "end", end)
        pulumi.set(__self__, "start", start)

    @property
    @pulumi.getter
    def end(self) -> str:
        return pulumi.get(self, "end")

    @property
    @pulumi.getter
    def start(self) -> str:
        return pulumi.get(self, "start")


@pulumi.output_type
class CampaignSchedule(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "endTime":
            suggest = "end_time"
        elif key == "eventFilter":
            suggest = "event_filter"
        elif key == "isLocalTime":
            suggest = "is_local_time"
        elif key == "quietTime":
            suggest = "quiet_time"
        elif key == "startTime":
            suggest = "start_time"
        elif key == "timeZone":
            suggest = "time_zone"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in CampaignSchedule. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        CampaignSchedule.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        CampaignSchedule.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 end_time: Optional[str] = None,
                 event_filter: Optional['outputs.CampaignCampaignEventFilter'] = None,
                 frequency: Optional[str] = None,
                 is_local_time: Optional[bool] = None,
                 quiet_time: Optional['outputs.CampaignQuietTime'] = None,
                 start_time: Optional[str] = None,
                 time_zone: Optional[str] = None):
        if end_time is not None:
            pulumi.set(__self__, "end_time", end_time)
        if event_filter is not None:
            pulumi.set(__self__, "event_filter", event_filter)
        if frequency is not None:
            pulumi.set(__self__, "frequency", frequency)
        if is_local_time is not None:
            pulumi.set(__self__, "is_local_time", is_local_time)
        if quiet_time is not None:
            pulumi.set(__self__, "quiet_time", quiet_time)
        if start_time is not None:
            pulumi.set(__self__, "start_time", start_time)
        if time_zone is not None:
            pulumi.set(__self__, "time_zone", time_zone)

    @property
    @pulumi.getter(name="endTime")
    def end_time(self) -> Optional[str]:
        return pulumi.get(self, "end_time")

    @property
    @pulumi.getter(name="eventFilter")
    def event_filter(self) -> Optional['outputs.CampaignCampaignEventFilter']:
        return pulumi.get(self, "event_filter")

    @property
    @pulumi.getter
    def frequency(self) -> Optional[str]:
        return pulumi.get(self, "frequency")

    @property
    @pulumi.getter(name="isLocalTime")
    def is_local_time(self) -> Optional[bool]:
        return pulumi.get(self, "is_local_time")

    @property
    @pulumi.getter(name="quietTime")
    def quiet_time(self) -> Optional['outputs.CampaignQuietTime']:
        return pulumi.get(self, "quiet_time")

    @property
    @pulumi.getter(name="startTime")
    def start_time(self) -> Optional[str]:
        return pulumi.get(self, "start_time")

    @property
    @pulumi.getter(name="timeZone")
    def time_zone(self) -> Optional[str]:
        return pulumi.get(self, "time_zone")


@pulumi.output_type
class CampaignSetDimension(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "dimensionType":
            suggest = "dimension_type"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in CampaignSetDimension. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        CampaignSetDimension.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        CampaignSetDimension.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 dimension_type: Optional[str] = None,
                 values: Optional[Sequence[str]] = None):
        if dimension_type is not None:
            pulumi.set(__self__, "dimension_type", dimension_type)
        if values is not None:
            pulumi.set(__self__, "values", values)

    @property
    @pulumi.getter(name="dimensionType")
    def dimension_type(self) -> Optional[str]:
        return pulumi.get(self, "dimension_type")

    @property
    @pulumi.getter
    def values(self) -> Optional[Sequence[str]]:
        return pulumi.get(self, "values")


@pulumi.output_type
class CampaignWriteTreatmentResource(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "messageConfiguration":
            suggest = "message_configuration"
        elif key == "sizePercent":
            suggest = "size_percent"
        elif key == "treatmentDescription":
            suggest = "treatment_description"
        elif key == "treatmentName":
            suggest = "treatment_name"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in CampaignWriteTreatmentResource. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        CampaignWriteTreatmentResource.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        CampaignWriteTreatmentResource.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 message_configuration: Optional['outputs.CampaignMessageConfiguration'] = None,
                 schedule: Optional['outputs.CampaignSchedule'] = None,
                 size_percent: Optional[int] = None,
                 treatment_description: Optional[str] = None,
                 treatment_name: Optional[str] = None):
        if message_configuration is not None:
            pulumi.set(__self__, "message_configuration", message_configuration)
        if schedule is not None:
            pulumi.set(__self__, "schedule", schedule)
        if size_percent is not None:
            pulumi.set(__self__, "size_percent", size_percent)
        if treatment_description is not None:
            pulumi.set(__self__, "treatment_description", treatment_description)
        if treatment_name is not None:
            pulumi.set(__self__, "treatment_name", treatment_name)

    @property
    @pulumi.getter(name="messageConfiguration")
    def message_configuration(self) -> Optional['outputs.CampaignMessageConfiguration']:
        return pulumi.get(self, "message_configuration")

    @property
    @pulumi.getter
    def schedule(self) -> Optional['outputs.CampaignSchedule']:
        return pulumi.get(self, "schedule")

    @property
    @pulumi.getter(name="sizePercent")
    def size_percent(self) -> Optional[int]:
        return pulumi.get(self, "size_percent")

    @property
    @pulumi.getter(name="treatmentDescription")
    def treatment_description(self) -> Optional[str]:
        return pulumi.get(self, "treatment_description")

    @property
    @pulumi.getter(name="treatmentName")
    def treatment_name(self) -> Optional[str]:
        return pulumi.get(self, "treatment_name")


@pulumi.output_type
class PushTemplateAPNSPushNotificationTemplate(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "mediaUrl":
            suggest = "media_url"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in PushTemplateAPNSPushNotificationTemplate. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        PushTemplateAPNSPushNotificationTemplate.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        PushTemplateAPNSPushNotificationTemplate.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 action: Optional[str] = None,
                 body: Optional[str] = None,
                 media_url: Optional[str] = None,
                 sound: Optional[str] = None,
                 title: Optional[str] = None,
                 url: Optional[str] = None):
        if action is not None:
            pulumi.set(__self__, "action", action)
        if body is not None:
            pulumi.set(__self__, "body", body)
        if media_url is not None:
            pulumi.set(__self__, "media_url", media_url)
        if sound is not None:
            pulumi.set(__self__, "sound", sound)
        if title is not None:
            pulumi.set(__self__, "title", title)
        if url is not None:
            pulumi.set(__self__, "url", url)

    @property
    @pulumi.getter
    def action(self) -> Optional[str]:
        return pulumi.get(self, "action")

    @property
    @pulumi.getter
    def body(self) -> Optional[str]:
        return pulumi.get(self, "body")

    @property
    @pulumi.getter(name="mediaUrl")
    def media_url(self) -> Optional[str]:
        return pulumi.get(self, "media_url")

    @property
    @pulumi.getter
    def sound(self) -> Optional[str]:
        return pulumi.get(self, "sound")

    @property
    @pulumi.getter
    def title(self) -> Optional[str]:
        return pulumi.get(self, "title")

    @property
    @pulumi.getter
    def url(self) -> Optional[str]:
        return pulumi.get(self, "url")


@pulumi.output_type
class PushTemplateAndroidPushNotificationTemplate(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "imageIconUrl":
            suggest = "image_icon_url"
        elif key == "imageUrl":
            suggest = "image_url"
        elif key == "smallImageIconUrl":
            suggest = "small_image_icon_url"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in PushTemplateAndroidPushNotificationTemplate. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        PushTemplateAndroidPushNotificationTemplate.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        PushTemplateAndroidPushNotificationTemplate.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 action: Optional[str] = None,
                 body: Optional[str] = None,
                 image_icon_url: Optional[str] = None,
                 image_url: Optional[str] = None,
                 small_image_icon_url: Optional[str] = None,
                 sound: Optional[str] = None,
                 title: Optional[str] = None,
                 url: Optional[str] = None):
        if action is not None:
            pulumi.set(__self__, "action", action)
        if body is not None:
            pulumi.set(__self__, "body", body)
        if image_icon_url is not None:
            pulumi.set(__self__, "image_icon_url", image_icon_url)
        if image_url is not None:
            pulumi.set(__self__, "image_url", image_url)
        if small_image_icon_url is not None:
            pulumi.set(__self__, "small_image_icon_url", small_image_icon_url)
        if sound is not None:
            pulumi.set(__self__, "sound", sound)
        if title is not None:
            pulumi.set(__self__, "title", title)
        if url is not None:
            pulumi.set(__self__, "url", url)

    @property
    @pulumi.getter
    def action(self) -> Optional[str]:
        return pulumi.get(self, "action")

    @property
    @pulumi.getter
    def body(self) -> Optional[str]:
        return pulumi.get(self, "body")

    @property
    @pulumi.getter(name="imageIconUrl")
    def image_icon_url(self) -> Optional[str]:
        return pulumi.get(self, "image_icon_url")

    @property
    @pulumi.getter(name="imageUrl")
    def image_url(self) -> Optional[str]:
        return pulumi.get(self, "image_url")

    @property
    @pulumi.getter(name="smallImageIconUrl")
    def small_image_icon_url(self) -> Optional[str]:
        return pulumi.get(self, "small_image_icon_url")

    @property
    @pulumi.getter
    def sound(self) -> Optional[str]:
        return pulumi.get(self, "sound")

    @property
    @pulumi.getter
    def title(self) -> Optional[str]:
        return pulumi.get(self, "title")

    @property
    @pulumi.getter
    def url(self) -> Optional[str]:
        return pulumi.get(self, "url")


@pulumi.output_type
class PushTemplateDefaultPushNotificationTemplate(dict):
    def __init__(__self__, *,
                 action: Optional[str] = None,
                 body: Optional[str] = None,
                 sound: Optional[str] = None,
                 title: Optional[str] = None,
                 url: Optional[str] = None):
        if action is not None:
            pulumi.set(__self__, "action", action)
        if body is not None:
            pulumi.set(__self__, "body", body)
        if sound is not None:
            pulumi.set(__self__, "sound", sound)
        if title is not None:
            pulumi.set(__self__, "title", title)
        if url is not None:
            pulumi.set(__self__, "url", url)

    @property
    @pulumi.getter
    def action(self) -> Optional[str]:
        return pulumi.get(self, "action")

    @property
    @pulumi.getter
    def body(self) -> Optional[str]:
        return pulumi.get(self, "body")

    @property
    @pulumi.getter
    def sound(self) -> Optional[str]:
        return pulumi.get(self, "sound")

    @property
    @pulumi.getter
    def title(self) -> Optional[str]:
        return pulumi.get(self, "title")

    @property
    @pulumi.getter
    def url(self) -> Optional[str]:
        return pulumi.get(self, "url")


@pulumi.output_type
class SegmentBehavior(dict):
    def __init__(__self__, *,
                 recency: Optional['outputs.SegmentRecency'] = None):
        if recency is not None:
            pulumi.set(__self__, "recency", recency)

    @property
    @pulumi.getter
    def recency(self) -> Optional['outputs.SegmentRecency']:
        return pulumi.get(self, "recency")


@pulumi.output_type
class SegmentCoordinates(dict):
    def __init__(__self__, *,
                 latitude: float,
                 longitude: float):
        pulumi.set(__self__, "latitude", latitude)
        pulumi.set(__self__, "longitude", longitude)

    @property
    @pulumi.getter
    def latitude(self) -> float:
        return pulumi.get(self, "latitude")

    @property
    @pulumi.getter
    def longitude(self) -> float:
        return pulumi.get(self, "longitude")


@pulumi.output_type
class SegmentDemographic(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "appVersion":
            suggest = "app_version"
        elif key == "deviceType":
            suggest = "device_type"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in SegmentDemographic. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        SegmentDemographic.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        SegmentDemographic.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 app_version: Optional['outputs.SegmentSetDimension'] = None,
                 channel: Optional['outputs.SegmentSetDimension'] = None,
                 device_type: Optional['outputs.SegmentSetDimension'] = None,
                 make: Optional['outputs.SegmentSetDimension'] = None,
                 model: Optional['outputs.SegmentSetDimension'] = None,
                 platform: Optional['outputs.SegmentSetDimension'] = None):
        if app_version is not None:
            pulumi.set(__self__, "app_version", app_version)
        if channel is not None:
            pulumi.set(__self__, "channel", channel)
        if device_type is not None:
            pulumi.set(__self__, "device_type", device_type)
        if make is not None:
            pulumi.set(__self__, "make", make)
        if model is not None:
            pulumi.set(__self__, "model", model)
        if platform is not None:
            pulumi.set(__self__, "platform", platform)

    @property
    @pulumi.getter(name="appVersion")
    def app_version(self) -> Optional['outputs.SegmentSetDimension']:
        return pulumi.get(self, "app_version")

    @property
    @pulumi.getter
    def channel(self) -> Optional['outputs.SegmentSetDimension']:
        return pulumi.get(self, "channel")

    @property
    @pulumi.getter(name="deviceType")
    def device_type(self) -> Optional['outputs.SegmentSetDimension']:
        return pulumi.get(self, "device_type")

    @property
    @pulumi.getter
    def make(self) -> Optional['outputs.SegmentSetDimension']:
        return pulumi.get(self, "make")

    @property
    @pulumi.getter
    def model(self) -> Optional['outputs.SegmentSetDimension']:
        return pulumi.get(self, "model")

    @property
    @pulumi.getter
    def platform(self) -> Optional['outputs.SegmentSetDimension']:
        return pulumi.get(self, "platform")


@pulumi.output_type
class SegmentGPSPoint(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "rangeInKilometers":
            suggest = "range_in_kilometers"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in SegmentGPSPoint. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        SegmentGPSPoint.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        SegmentGPSPoint.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 coordinates: 'outputs.SegmentCoordinates',
                 range_in_kilometers: float):
        pulumi.set(__self__, "coordinates", coordinates)
        pulumi.set(__self__, "range_in_kilometers", range_in_kilometers)

    @property
    @pulumi.getter
    def coordinates(self) -> 'outputs.SegmentCoordinates':
        return pulumi.get(self, "coordinates")

    @property
    @pulumi.getter(name="rangeInKilometers")
    def range_in_kilometers(self) -> float:
        return pulumi.get(self, "range_in_kilometers")


@pulumi.output_type
class SegmentGroups(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "sourceSegments":
            suggest = "source_segments"
        elif key == "sourceType":
            suggest = "source_type"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in SegmentGroups. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        SegmentGroups.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        SegmentGroups.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 dimensions: Optional[Sequence['outputs.SegmentSegmentDimensions']] = None,
                 source_segments: Optional[Sequence['outputs.SegmentSourceSegments']] = None,
                 source_type: Optional[str] = None,
                 type: Optional[str] = None):
        if dimensions is not None:
            pulumi.set(__self__, "dimensions", dimensions)
        if source_segments is not None:
            pulumi.set(__self__, "source_segments", source_segments)
        if source_type is not None:
            pulumi.set(__self__, "source_type", source_type)
        if type is not None:
            pulumi.set(__self__, "type", type)

    @property
    @pulumi.getter
    def dimensions(self) -> Optional[Sequence['outputs.SegmentSegmentDimensions']]:
        return pulumi.get(self, "dimensions")

    @property
    @pulumi.getter(name="sourceSegments")
    def source_segments(self) -> Optional[Sequence['outputs.SegmentSourceSegments']]:
        return pulumi.get(self, "source_segments")

    @property
    @pulumi.getter(name="sourceType")
    def source_type(self) -> Optional[str]:
        return pulumi.get(self, "source_type")

    @property
    @pulumi.getter
    def type(self) -> Optional[str]:
        return pulumi.get(self, "type")


@pulumi.output_type
class SegmentLocation(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "gPSPoint":
            suggest = "g_ps_point"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in SegmentLocation. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        SegmentLocation.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        SegmentLocation.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 country: Optional['outputs.SegmentSetDimension'] = None,
                 g_ps_point: Optional['outputs.SegmentGPSPoint'] = None):
        if country is not None:
            pulumi.set(__self__, "country", country)
        if g_ps_point is not None:
            pulumi.set(__self__, "g_ps_point", g_ps_point)

    @property
    @pulumi.getter
    def country(self) -> Optional['outputs.SegmentSetDimension']:
        return pulumi.get(self, "country")

    @property
    @pulumi.getter(name="gPSPoint")
    def g_ps_point(self) -> Optional['outputs.SegmentGPSPoint']:
        return pulumi.get(self, "g_ps_point")


@pulumi.output_type
class SegmentRecency(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "recencyType":
            suggest = "recency_type"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in SegmentRecency. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        SegmentRecency.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        SegmentRecency.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 duration: str,
                 recency_type: str):
        pulumi.set(__self__, "duration", duration)
        pulumi.set(__self__, "recency_type", recency_type)

    @property
    @pulumi.getter
    def duration(self) -> str:
        return pulumi.get(self, "duration")

    @property
    @pulumi.getter(name="recencyType")
    def recency_type(self) -> str:
        return pulumi.get(self, "recency_type")


@pulumi.output_type
class SegmentSegmentDimensions(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "userAttributes":
            suggest = "user_attributes"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in SegmentSegmentDimensions. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        SegmentSegmentDimensions.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        SegmentSegmentDimensions.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 attributes: Optional[Any] = None,
                 behavior: Optional['outputs.SegmentBehavior'] = None,
                 demographic: Optional['outputs.SegmentDemographic'] = None,
                 location: Optional['outputs.SegmentLocation'] = None,
                 metrics: Optional[Any] = None,
                 user_attributes: Optional[Any] = None):
        if attributes is not None:
            pulumi.set(__self__, "attributes", attributes)
        if behavior is not None:
            pulumi.set(__self__, "behavior", behavior)
        if demographic is not None:
            pulumi.set(__self__, "demographic", demographic)
        if location is not None:
            pulumi.set(__self__, "location", location)
        if metrics is not None:
            pulumi.set(__self__, "metrics", metrics)
        if user_attributes is not None:
            pulumi.set(__self__, "user_attributes", user_attributes)

    @property
    @pulumi.getter
    def attributes(self) -> Optional[Any]:
        return pulumi.get(self, "attributes")

    @property
    @pulumi.getter
    def behavior(self) -> Optional['outputs.SegmentBehavior']:
        return pulumi.get(self, "behavior")

    @property
    @pulumi.getter
    def demographic(self) -> Optional['outputs.SegmentDemographic']:
        return pulumi.get(self, "demographic")

    @property
    @pulumi.getter
    def location(self) -> Optional['outputs.SegmentLocation']:
        return pulumi.get(self, "location")

    @property
    @pulumi.getter
    def metrics(self) -> Optional[Any]:
        return pulumi.get(self, "metrics")

    @property
    @pulumi.getter(name="userAttributes")
    def user_attributes(self) -> Optional[Any]:
        return pulumi.get(self, "user_attributes")


@pulumi.output_type
class SegmentSegmentGroups(dict):
    def __init__(__self__, *,
                 groups: Optional[Sequence['outputs.SegmentGroups']] = None,
                 include: Optional[str] = None):
        if groups is not None:
            pulumi.set(__self__, "groups", groups)
        if include is not None:
            pulumi.set(__self__, "include", include)

    @property
    @pulumi.getter
    def groups(self) -> Optional[Sequence['outputs.SegmentGroups']]:
        return pulumi.get(self, "groups")

    @property
    @pulumi.getter
    def include(self) -> Optional[str]:
        return pulumi.get(self, "include")


@pulumi.output_type
class SegmentSetDimension(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "dimensionType":
            suggest = "dimension_type"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in SegmentSetDimension. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        SegmentSetDimension.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        SegmentSetDimension.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 dimension_type: Optional[str] = None,
                 values: Optional[Sequence[str]] = None):
        if dimension_type is not None:
            pulumi.set(__self__, "dimension_type", dimension_type)
        if values is not None:
            pulumi.set(__self__, "values", values)

    @property
    @pulumi.getter(name="dimensionType")
    def dimension_type(self) -> Optional[str]:
        return pulumi.get(self, "dimension_type")

    @property
    @pulumi.getter
    def values(self) -> Optional[Sequence[str]]:
        return pulumi.get(self, "values")


@pulumi.output_type
class SegmentSourceSegments(dict):
    def __init__(__self__, *,
                 id: str,
                 version: Optional[int] = None):
        pulumi.set(__self__, "id", id)
        if version is not None:
            pulumi.set(__self__, "version", version)

    @property
    @pulumi.getter
    def id(self) -> str:
        return pulumi.get(self, "id")

    @property
    @pulumi.getter
    def version(self) -> Optional[int]:
        return pulumi.get(self, "version")


