leadping 1.0.0__py3-none-any.whl

leadping/models/conversation_response.py

@@ -0,0 +1,132 @@
+from __future__ import annotations
+import datetime
+from collections.abc import Callable
+from dataclasses import dataclass, field
+from kiota_abstractions.serialization import AdditionalDataHolder, Parsable, ParseNode, SerializationWriter
+from typing import Any, Optional, TYPE_CHECKING, Union
+
+if TYPE_CHECKING:
+    from .conversation_response_current_disposition import ConversationResponse_currentDisposition
+    from .conversation_response_phone_number import ConversationResponse_phoneNumber
+    from .conversation_response_status import ConversationResponse_status
+
+@dataclass
+class ConversationResponse(AdditionalDataHolder, Parsable):
+    """
+    API response containing conversation data returned to callers.
+    """
+    # Stores additional data not described in the OpenAPI description found when deserializing. Can be used for serialization as well.
+    additional_data: dict[str, Any] = field(default_factory=dict)
+
+    # The active outbound phone number ID associated with this conversation.
+    active_outbound_phone_number_id: Optional[str] = None
+    # Defines why a lead was removed from the active working pipeline.
+    archive_reason: Optional[int] = None
+    # The archivedAt property
+    archived_at: Optional[datetime.datetime] = None
+    # The current lifecycle disposition for the conversation's lead.
+    current_disposition: Optional[ConversationResponse_currentDisposition] = None
+    # The first name value for this conversation.
+    first_name: Optional[str] = None
+    # The unique ID for this conversation.
+    id: Optional[str] = None
+    # The isArchived property
+    is_archived: Optional[bool] = None
+    # Whether this conversation is unread.
+    is_unread: Optional[bool] = None
+    # The date and time for the last event at value on this conversation.
+    last_event_at: Optional[datetime.datetime] = None
+    # The date and time for the last name value on this conversation.
+    last_name: Optional[str] = None
+    # The date and time for the last snippet value on this conversation.
+    last_snippet: Optional[str] = None
+    # The lead ID associated with this conversation.
+    lead_id: Optional[str] = None
+    # The lead's primary contact phone number for this conversation.
+    lead_phone_number: Optional[str] = None
+    # The recommended next action for the inbox user.
+    next_step: Optional[str] = None
+    # The outbound phone number override ID associated with this conversation.
+    outbound_phone_number_override_id: Optional[str] = None
+    # The Leadping sender phone number associated with this conversation.
+    phone_number: Optional[ConversationResponse_phoneNumber] = None
+    # Defines the customer-facing operational status for an inbox conversation.
+    status: Optional[ConversationResponse_status] = None
+    # The human-readable reason explaining the current conversation status.
+    status_reason: Optional[str] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> ConversationResponse:
+        """
+        Creates a new instance of the appropriate class based on discriminator value
+        param parse_node: The parse node to use to read the discriminator value and create the object
+        Returns: ConversationResponse
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return ConversationResponse()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .conversation_response_current_disposition import ConversationResponse_currentDisposition
+        from .conversation_response_phone_number import ConversationResponse_phoneNumber
+        from .conversation_response_status import ConversationResponse_status
+
+        from .conversation_response_current_disposition import ConversationResponse_currentDisposition
+        from .conversation_response_phone_number import ConversationResponse_phoneNumber
+        from .conversation_response_status import ConversationResponse_status
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "activeOutboundPhoneNumberId": lambda n : setattr(self, 'active_outbound_phone_number_id', n.get_str_value()),
+            "archiveReason": lambda n : setattr(self, 'archive_reason', n.get_int_value()),
+            "archivedAt": lambda n : setattr(self, 'archived_at', n.get_datetime_value()),
+            "currentDisposition": lambda n : setattr(self, 'current_disposition', n.get_object_value(ConversationResponse_currentDisposition)),
+            "firstName": lambda n : setattr(self, 'first_name', n.get_str_value()),
+            "id": lambda n : setattr(self, 'id', n.get_str_value()),
+            "isArchived": lambda n : setattr(self, 'is_archived', n.get_bool_value()),
+            "isUnread": lambda n : setattr(self, 'is_unread', n.get_bool_value()),
+            "lastEventAt": lambda n : setattr(self, 'last_event_at', n.get_datetime_value()),
+            "lastName": lambda n : setattr(self, 'last_name', n.get_str_value()),
+            "lastSnippet": lambda n : setattr(self, 'last_snippet', n.get_str_value()),
+            "leadId": lambda n : setattr(self, 'lead_id', n.get_str_value()),
+            "leadPhoneNumber": lambda n : setattr(self, 'lead_phone_number', n.get_str_value()),
+            "nextStep": lambda n : setattr(self, 'next_step', n.get_str_value()),
+            "outboundPhoneNumberOverrideId": lambda n : setattr(self, 'outbound_phone_number_override_id', n.get_str_value()),
+            "phoneNumber": lambda n : setattr(self, 'phone_number', n.get_object_value(ConversationResponse_phoneNumber)),
+            "status": lambda n : setattr(self, 'status', n.get_enum_value(ConversationResponse_status)),
+            "statusReason": lambda n : setattr(self, 'status_reason', n.get_str_value()),
+        }
+        return fields
+    
+    def serialize(self,writer: SerializationWriter) -> None:
+        """
+        Serializes information the current object
+        param writer: Serialization writer to use to serialize this model
+        Returns: None
+        """
+        if writer is None:
+            raise TypeError("writer cannot be null.")
+        writer.write_str_value("activeOutboundPhoneNumberId", self.active_outbound_phone_number_id)
+        writer.write_int_value("archiveReason", self.archive_reason)
+        writer.write_datetime_value("archivedAt", self.archived_at)
+        writer.write_object_value("currentDisposition", self.current_disposition)
+        writer.write_str_value("firstName", self.first_name)
+        writer.write_str_value("id", self.id)
+        writer.write_bool_value("isArchived", self.is_archived)
+        writer.write_bool_value("isUnread", self.is_unread)
+        writer.write_datetime_value("lastEventAt", self.last_event_at)
+        writer.write_str_value("lastName", self.last_name)
+        writer.write_str_value("lastSnippet", self.last_snippet)
+        writer.write_str_value("leadId", self.lead_id)
+        writer.write_str_value("leadPhoneNumber", self.lead_phone_number)
+        writer.write_str_value("nextStep", self.next_step)
+        writer.write_str_value("outboundPhoneNumberOverrideId", self.outbound_phone_number_override_id)
+        writer.write_object_value("phoneNumber", self.phone_number)
+        writer.write_enum_value("status", self.status)
+        writer.write_str_value("statusReason", self.status_reason)
+        writer.write_additional_data_value(self.additional_data)
+    
+

leadping/models/conversation_response_current_disposition.py

@@ -0,0 +1,54 @@
+from __future__ import annotations
+from collections.abc import Callable
+from dataclasses import dataclass, field
+from kiota_abstractions.serialization import Parsable, ParseNode, SerializationWriter
+from typing import Any, Optional, TYPE_CHECKING, Union
+
+if TYPE_CHECKING:
+    from .current_disposition_summary import CurrentDispositionSummary
+
+from .current_disposition_summary import CurrentDispositionSummary
+
+@dataclass
+class ConversationResponse_currentDisposition(CurrentDispositionSummary, Parsable):
+    """
+    The current lifecycle disposition for the conversation's lead.
+    """
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> ConversationResponse_currentDisposition:
+        """
+        Creates a new instance of the appropriate class based on discriminator value
+        param parse_node: The parse node to use to read the discriminator value and create the object
+        Returns: ConversationResponse_currentDisposition
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return ConversationResponse_currentDisposition()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .current_disposition_summary import CurrentDispositionSummary
+
+        from .current_disposition_summary import CurrentDispositionSummary
+
+        fields: dict[str, Callable[[Any], None]] = {
+        }
+        super_fields = super().get_field_deserializers()
+        fields.update(super_fields)
+        return fields
+    
+    def serialize(self,writer: SerializationWriter) -> None:
+        """
+        Serializes information the current object
+        param writer: Serialization writer to use to serialize this model
+        Returns: None
+        """
+        if writer is None:
+            raise TypeError("writer cannot be null.")
+        super().serialize(writer)
+    
+

leadping/models/conversation_response_phone_number.py

@@ -0,0 +1,54 @@
+from __future__ import annotations
+from collections.abc import Callable
+from dataclasses import dataclass, field
+from kiota_abstractions.serialization import Parsable, ParseNode, SerializationWriter
+from typing import Any, Optional, TYPE_CHECKING, Union
+
+if TYPE_CHECKING:
+    from .id_name_value import IdNameValue
+
+from .id_name_value import IdNameValue
+
+@dataclass
+class ConversationResponse_phoneNumber(IdNameValue, Parsable):
+    """
+    The Leadping sender phone number associated with this conversation.
+    """
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> ConversationResponse_phoneNumber:
+        """
+        Creates a new instance of the appropriate class based on discriminator value
+        param parse_node: The parse node to use to read the discriminator value and create the object
+        Returns: ConversationResponse_phoneNumber
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return ConversationResponse_phoneNumber()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .id_name_value import IdNameValue
+
+        from .id_name_value import IdNameValue
+
+        fields: dict[str, Callable[[Any], None]] = {
+        }
+        super_fields = super().get_field_deserializers()
+        fields.update(super_fields)
+        return fields
+    
+    def serialize(self,writer: SerializationWriter) -> None:
+        """
+        Serializes information the current object
+        param writer: Serialization writer to use to serialize this model
+        Returns: None
+        """
+        if writer is None:
+            raise TypeError("writer cannot be null.")
+        super().serialize(writer)
+    
+

leadping/models/conversation_response_status.py

@@ -0,0 +1,8 @@
+from enum import Enum
+
+class ConversationResponse_status(str, Enum):
+    Needs_reply = "needs_reply",
+    Waiting = "waiting",
+    Failed = "failed",
+    Open = "open",
+

leadping/models/coordinate.py

@@ -0,0 +1,54 @@
+from __future__ import annotations
+from collections.abc import Callable
+from dataclasses import dataclass, field
+from kiota_abstractions.serialization import AdditionalDataHolder, Parsable, ParseNode, SerializationWriter
+from typing import Any, Optional, TYPE_CHECKING, Union
+
+@dataclass
+class Coordinate(AdditionalDataHolder, Parsable):
+    """
+    The coordinate inferred for this lead contact.
+    """
+    # Stores additional data not described in the OpenAPI description found when deserializing. Can be used for serialization as well.
+    additional_data: dict[str, Any] = field(default_factory=dict)
+
+    # The latitude property
+    latitude: Optional[float] = None
+    # The longitude property
+    longitude: Optional[float] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> Coordinate:
+        """
+        Creates a new instance of the appropriate class based on discriminator value
+        param parse_node: The parse node to use to read the discriminator value and create the object
+        Returns: Coordinate
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return Coordinate()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        fields: dict[str, Callable[[Any], None]] = {
+            "latitude": lambda n : setattr(self, 'latitude', n.get_float_value()),
+            "longitude": lambda n : setattr(self, 'longitude', n.get_float_value()),
+        }
+        return fields
+    
+    def serialize(self,writer: SerializationWriter) -> None:
+        """
+        Serializes information the current object
+        param writer: Serialization writer to use to serialize this model
+        Returns: None
+        """
+        if writer is None:
+            raise TypeError("writer cannot be null.")
+        writer.write_float_value("latitude", self.latitude)
+        writer.write_float_value("longitude", self.longitude)
+        writer.write_additional_data_value(self.additional_data)
+    
+

leadping/models/create_note_request.py

@@ -0,0 +1,50 @@
+from __future__ import annotations
+from collections.abc import Callable
+from dataclasses import dataclass, field
+from kiota_abstractions.serialization import AdditionalDataHolder, Parsable, ParseNode, SerializationWriter
+from typing import Any, Optional, TYPE_CHECKING, Union
+
+@dataclass
+class CreateNoteRequest(AdditionalDataHolder, Parsable):
+    """
+    Request payload for create note.
+    """
+    # Stores additional data not described in the OpenAPI description found when deserializing. Can be used for serialization as well.
+    additional_data: dict[str, Any] = field(default_factory=dict)
+
+    # The text value for this note.
+    text: Optional[str] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> CreateNoteRequest:
+        """
+        Creates a new instance of the appropriate class based on discriminator value
+        param parse_node: The parse node to use to read the discriminator value and create the object
+        Returns: CreateNoteRequest
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return CreateNoteRequest()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        fields: dict[str, Callable[[Any], None]] = {
+            "text": lambda n : setattr(self, 'text', n.get_str_value()),
+        }
+        return fields
+    
+    def serialize(self,writer: SerializationWriter) -> None:
+        """
+        Serializes information the current object
+        param writer: Serialization writer to use to serialize this model
+        Returns: None
+        """
+        if writer is None:
+            raise TypeError("writer cannot be null.")
+        writer.write_str_value("text", self.text)
+        writer.write_additional_data_value(self.additional_data)
+    
+

leadping/models/current_disposition_summary.py

@@ -0,0 +1,89 @@
+from __future__ import annotations
+import datetime
+from collections.abc import Callable
+from dataclasses import dataclass, field
+from kiota_abstractions.serialization import AdditionalDataHolder, Parsable, ParseNode, SerializationWriter
+from typing import Any, Optional, TYPE_CHECKING, Union
+
+if TYPE_CHECKING:
+    from .current_disposition_summary_category import CurrentDispositionSummary_category
+    from .current_disposition_summary_source import CurrentDispositionSummary_source
+
+@dataclass
+class CurrentDispositionSummary(AdditionalDataHolder, Parsable):
+    """
+    Compact current disposition state stored directly on a lead and surfaced with conversation data.
+    """
+    # Stores additional data not described in the OpenAPI description found when deserializing. Can be used for serialization as well.
+    additional_data: dict[str, Any] = field(default_factory=dict)
+
+    # Controlled disposition categories used for reporting, automation, and analytics.
+    category: Optional[CurrentDispositionSummary_category] = None
+    # The changedAt property
+    changed_at: Optional[datetime.datetime] = None
+    # The changedByAutomationId property
+    changed_by_automation_id: Optional[str] = None
+    # The changedByUserId property
+    changed_by_user_id: Optional[str] = None
+    # The displayName property
+    display_name: Optional[str] = None
+    # The id property
+    id: Optional[str] = None
+    # The outcome property
+    outcome: Optional[str] = None
+    # Known sources that can change a lead's current disposition.
+    source: Optional[CurrentDispositionSummary_source] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> CurrentDispositionSummary:
+        """
+        Creates a new instance of the appropriate class based on discriminator value
+        param parse_node: The parse node to use to read the discriminator value and create the object
+        Returns: CurrentDispositionSummary
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return CurrentDispositionSummary()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .current_disposition_summary_category import CurrentDispositionSummary_category
+        from .current_disposition_summary_source import CurrentDispositionSummary_source
+
+        from .current_disposition_summary_category import CurrentDispositionSummary_category
+        from .current_disposition_summary_source import CurrentDispositionSummary_source
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "category": lambda n : setattr(self, 'category', n.get_enum_value(CurrentDispositionSummary_category)),
+            "changedAt": lambda n : setattr(self, 'changed_at', n.get_datetime_value()),
+            "changedByAutomationId": lambda n : setattr(self, 'changed_by_automation_id', n.get_str_value()),
+            "changedByUserId": lambda n : setattr(self, 'changed_by_user_id', n.get_str_value()),
+            "displayName": lambda n : setattr(self, 'display_name', n.get_str_value()),
+            "id": lambda n : setattr(self, 'id', n.get_str_value()),
+            "outcome": lambda n : setattr(self, 'outcome', n.get_str_value()),
+            "source": lambda n : setattr(self, 'source', n.get_enum_value(CurrentDispositionSummary_source)),
+        }
+        return fields
+    
+    def serialize(self,writer: SerializationWriter) -> None:
+        """
+        Serializes information the current object
+        param writer: Serialization writer to use to serialize this model
+        Returns: None
+        """
+        if writer is None:
+            raise TypeError("writer cannot be null.")
+        writer.write_enum_value("category", self.category)
+        writer.write_datetime_value("changedAt", self.changed_at)
+        writer.write_str_value("changedByAutomationId", self.changed_by_automation_id)
+        writer.write_str_value("changedByUserId", self.changed_by_user_id)
+        writer.write_str_value("displayName", self.display_name)
+        writer.write_str_value("id", self.id)
+        writer.write_str_value("outcome", self.outcome)
+        writer.write_enum_value("source", self.source)
+        writer.write_additional_data_value(self.additional_data)
+    
+

leadping/models/current_disposition_summary_category.py

@@ -0,0 +1,10 @@
+from enum import Enum
+
+class CurrentDispositionSummary_category(str, Enum):
+    Open = "Open",
+    Qualified = "Qualified",
+    Converted = "Converted",
+    Lost = "Lost",
+    Invalid = "Invalid",
+    Duplicate = "Duplicate",
+

leadping/models/current_disposition_summary_source.py

@@ -0,0 +1,9 @@
+from enum import Enum
+
+class CurrentDispositionSummary_source(str, Enum):
+    User = "User",
+    AI = "AI",
+    Automation = "Automation",
+    System = "System",
+    API = "API",
+

leadping/models/customer_activation_health.py

@@ -0,0 +1,58 @@
+from __future__ import annotations
+from collections.abc import Callable
+from dataclasses import dataclass, field
+from kiota_abstractions.serialization import AdditionalDataHolder, Parsable, ParseNode, SerializationWriter
+from typing import Any, Optional, TYPE_CHECKING, Union
+
+if TYPE_CHECKING:
+    from .customer_activation_health_item import CustomerActivationHealthItem
+
+@dataclass
+class CustomerActivationHealth(AdditionalDataHolder, Parsable):
+    # Stores additional data not described in the OpenAPI description found when deserializing. Can be used for serialization as well.
+    additional_data: dict[str, Any] = field(default_factory=dict)
+
+    # The items property
+    items: Optional[list[CustomerActivationHealthItem]] = None
+    # The overallStatus property
+    overall_status: Optional[str] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> CustomerActivationHealth:
+        """
+        Creates a new instance of the appropriate class based on discriminator value
+        param parse_node: The parse node to use to read the discriminator value and create the object
+        Returns: CustomerActivationHealth
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return CustomerActivationHealth()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        from .customer_activation_health_item import CustomerActivationHealthItem
+
+        from .customer_activation_health_item import CustomerActivationHealthItem
+
+        fields: dict[str, Callable[[Any], None]] = {
+            "items": lambda n : setattr(self, 'items', n.get_collection_of_object_values(CustomerActivationHealthItem)),
+            "overallStatus": lambda n : setattr(self, 'overall_status', n.get_str_value()),
+        }
+        return fields
+    
+    def serialize(self,writer: SerializationWriter) -> None:
+        """
+        Serializes information the current object
+        param writer: Serialization writer to use to serialize this model
+        Returns: None
+        """
+        if writer is None:
+            raise TypeError("writer cannot be null.")
+        writer.write_collection_of_object_values("items", self.items)
+        writer.write_str_value("overallStatus", self.overall_status)
+        writer.write_additional_data_value(self.additional_data)
+    
+

leadping/models/customer_activation_health_item.py

@@ -0,0 +1,63 @@
+from __future__ import annotations
+from collections.abc import Callable
+from dataclasses import dataclass, field
+from kiota_abstractions.serialization import AdditionalDataHolder, Parsable, ParseNode, SerializationWriter
+from typing import Any, Optional, TYPE_CHECKING, Union
+
+@dataclass
+class CustomerActivationHealthItem(AdditionalDataHolder, Parsable):
+    # Stores additional data not described in the OpenAPI description found when deserializing. Can be used for serialization as well.
+    additional_data: dict[str, Any] = field(default_factory=dict)
+
+    # The actionHref property
+    action_href: Optional[str] = None
+    # The detail property
+    detail: Optional[str] = None
+    # The key property
+    key: Optional[str] = None
+    # The label property
+    label: Optional[str] = None
+    # The status property
+    status: Optional[str] = None
+    
+    @staticmethod
+    def create_from_discriminator_value(parse_node: ParseNode) -> CustomerActivationHealthItem:
+        """
+        Creates a new instance of the appropriate class based on discriminator value
+        param parse_node: The parse node to use to read the discriminator value and create the object
+        Returns: CustomerActivationHealthItem
+        """
+        if parse_node is None:
+            raise TypeError("parse_node cannot be null.")
+        return CustomerActivationHealthItem()
+    
+    def get_field_deserializers(self,) -> dict[str, Callable[[ParseNode], None]]:
+        """
+        The deserialization information for the current model
+        Returns: dict[str, Callable[[ParseNode], None]]
+        """
+        fields: dict[str, Callable[[Any], None]] = {
+            "actionHref": lambda n : setattr(self, 'action_href', n.get_str_value()),
+            "detail": lambda n : setattr(self, 'detail', n.get_str_value()),
+            "key": lambda n : setattr(self, 'key', n.get_str_value()),
+            "label": lambda n : setattr(self, 'label', n.get_str_value()),
+            "status": lambda n : setattr(self, 'status', n.get_str_value()),
+        }
+        return fields
+    
+    def serialize(self,writer: SerializationWriter) -> None:
+        """
+        Serializes information the current object
+        param writer: Serialization writer to use to serialize this model
+        Returns: None
+        """
+        if writer is None:
+            raise TypeError("writer cannot be null.")
+        writer.write_str_value("actionHref", self.action_href)
+        writer.write_str_value("detail", self.detail)
+        writer.write_str_value("key", self.key)
+        writer.write_str_value("label", self.label)
+        writer.write_str_value("status", self.status)
+        writer.write_additional_data_value(self.additional_data)
+    
+

leadping/models/customer_activation_status.py

@@ -0,0 +1,24 @@
+from enum import Enum
+
+class CustomerActivationStatus(str, Enum):
+    DraftOnboarding = "DraftOnboarding",
+    PaymentMethodPending = "PaymentMethodPending",
+    PaymentMethodConfirmed = "PaymentMethodConfirmed",
+    SubscriptionPending = "SubscriptionPending",
+    SubscriptionReceived = "SubscriptionReceived",
+    SubscriptionActive = "SubscriptionActive",
+    LaunchReviewPending = "LaunchReviewPending",
+    TelephonyProvisioningPending = "TelephonyProvisioningPending",
+    TelephonyPartiallyProvisioned = "TelephonyPartiallyProvisioned",
+    TelephonyReady = "TelephonyReady",
+    AwaitingReview = "AwaitingReview",
+    DomainSelection = "DomainSelection",
+    WebsiteSetup = "WebsiteSetup",
+    ComplianceRegistration = "ComplianceRegistration",
+    ReadyForApproval = "ReadyForApproval",
+    Active = "Active",
+    Failed = "Failed",
+    Blocked = "Blocked",
+    BlockedRequiresOperatorAction = "BlockedRequiresOperatorAction",
+    ManuallyBypassed = "ManuallyBypassed",
+