linq-python 0.1.0__py3-none-any.whl

linq/types/contact_card_retrieve_response.py

@@ -0,0 +1,23 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import List, Optional
+
+from .._models import BaseModel
+
+__all__ = ["ContactCardRetrieveResponse", "ContactCard"]
+
+
+class ContactCard(BaseModel):
+    first_name: str
+
+    is_active: bool
+
+    phone_number: str
+
+    image_url: Optional[str] = None
+
+    last_name: Optional[str] = None
+
+
+class ContactCardRetrieveResponse(BaseModel):
+    contact_cards: List[ContactCard]

linq/types/contact_card_update_params.py

@@ -0,0 +1,21 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import Required, TypedDict
+
+__all__ = ["ContactCardUpdateParams"]
+
+
+class ContactCardUpdateParams(TypedDict, total=False):
+    phone_number: Required[str]
+    """E.164 phone number of the contact card to update"""
+
+    first_name: str
+    """Updated first name. If omitted, the existing value is kept."""
+
+    image_url: str
+    """Updated profile image URL. If omitted, the existing image is kept."""
+
+    last_name: str
+    """Updated last name. If omitted, the existing value is kept."""

linq/types/events_webhook_event.py

@@ -0,0 +1,50 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Union
+from typing_extensions import Annotated, TypeAlias
+
+from .._utils import PropertyInfo
+from .chat_created_webhook_event import ChatCreatedWebhookEvent
+from .message_read_webhook_event import MessageReadWebhookEvent
+from .message_sent_webhook_event import MessageSentWebhookEvent
+from .message_edited_webhook_event import MessageEditedWebhookEvent
+from .message_failed_webhook_event import MessageFailedWebhookEvent
+from .reaction_added_webhook_event import ReactionAddedWebhookEvent
+from .message_received_webhook_event import MessageReceivedWebhookEvent
+from .reaction_removed_webhook_event import ReactionRemovedWebhookEvent
+from .message_delivered_webhook_event import MessageDeliveredWebhookEvent
+from .participant_added_webhook_event import ParticipantAddedWebhookEvent
+from .participant_removed_webhook_event import ParticipantRemovedWebhookEvent
+from .chat_group_icon_updated_webhook_event import ChatGroupIconUpdatedWebhookEvent
+from .chat_group_name_updated_webhook_event import ChatGroupNameUpdatedWebhookEvent
+from .phone_number_status_updated_webhook_event import PhoneNumberStatusUpdatedWebhookEvent
+from .chat_group_icon_update_failed_webhook_event import ChatGroupIconUpdateFailedWebhookEvent
+from .chat_group_name_update_failed_webhook_event import ChatGroupNameUpdateFailedWebhookEvent
+from .chat_typing_indicator_started_webhook_event import ChatTypingIndicatorStartedWebhookEvent
+from .chat_typing_indicator_stopped_webhook_event import ChatTypingIndicatorStoppedWebhookEvent
+
+__all__ = ["EventsWebhookEvent"]
+
+EventsWebhookEvent: TypeAlias = Annotated[
+    Union[
+        MessageSentWebhookEvent,
+        MessageReceivedWebhookEvent,
+        MessageReadWebhookEvent,
+        MessageDeliveredWebhookEvent,
+        MessageFailedWebhookEvent,
+        MessageEditedWebhookEvent,
+        ReactionAddedWebhookEvent,
+        ReactionRemovedWebhookEvent,
+        ParticipantAddedWebhookEvent,
+        ParticipantRemovedWebhookEvent,
+        ChatCreatedWebhookEvent,
+        ChatGroupNameUpdatedWebhookEvent,
+        ChatGroupIconUpdatedWebhookEvent,
+        ChatGroupNameUpdateFailedWebhookEvent,
+        ChatGroupIconUpdateFailedWebhookEvent,
+        ChatTypingIndicatorStartedWebhookEvent,
+        ChatTypingIndicatorStoppedWebhookEvent,
+        PhoneNumberStatusUpdatedWebhookEvent,
+    ],
+    PropertyInfo(discriminator="event_type"),
+]

linq/types/handle_check_response.py

@@ -0,0 +1,13 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from .._models import BaseModel
+
+__all__ = ["HandleCheckResponse"]
+
+
+class HandleCheckResponse(BaseModel):
+    address: str
+    """The recipient address that was checked"""
+
+    available: bool
+    """Whether the recipient supports the checked messaging service"""

linq/types/link_part_param.py

@@ -0,0 +1,22 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import Literal, Required, TypedDict
+
+__all__ = ["LinkPartParam"]
+
+
+class LinkPartParam(TypedDict, total=False):
+    type: Required[Literal["link"]]
+    """Indicates this is a rich link preview part"""
+
+    value: Required[str]
+    """URL to send with a rich link preview.
+
+    The recipient will see an inline card with the page's title, description, and
+    preview image (when available).
+
+    A `link` part must be the **only** part in the message. To send a URL as plain
+    text (no preview card), use a `text` part instead.
+    """

linq/types/media_part_param.py

@@ -0,0 +1,54 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import Literal, Required, TypedDict
+
+__all__ = ["MediaPartParam"]
+
+
+class MediaPartParam(TypedDict, total=False):
+    type: Required[Literal["media"]]
+    """Indicates this is a media attachment part"""
+
+    attachment_id: str
+    """
+    Reference to a file pre-uploaded via `POST /v3/attachments` (optional). The file
+    is already stored, so sends using this ID skip the download step — useful when
+    sending the same file to many recipients.
+
+    Either `url` or `attachment_id` must be provided, but not both.
+    """
+
+    url: str
+    """Any publicly accessible HTTPS URL to the media file.
+
+    The server downloads and sends the file automatically — no pre-upload step
+    required.
+
+    **Size limit:** 10MB maximum for URL-based downloads. For larger files (up to
+    100MB), use the pre-upload flow: `POST /v3/attachments` to get a presigned URL,
+    upload directly, then reference by `attachment_id`.
+
+    **Requirements:**
+
+    - URL must use HTTPS
+    - File content must be a supported format (the server validates the actual file
+      content)
+
+    **Supported formats:**
+
+    - Images: .jpg, .jpeg, .png, .gif, .heic, .heif, .tif, .tiff, .bmp
+    - Videos: .mp4, .mov, .m4v, .mpeg, .mpg, .3gp
+    - Audio: .m4a, .mp3, .aac, .caf, .wav, .aiff, .amr
+    - Documents: .pdf, .txt, .rtf, .csv, .doc, .docx, .xls, .xlsx, .ppt, .pptx,
+      .pages, .numbers, .key, .epub, .zip, .html, .htm
+    - Contact & Calendar: .vcf, .ics
+
+    **Tip:** Audio sent here appears as a regular file attachment. To send audio as
+    an iMessage voice memo bubble (with inline playback), use
+    `/v3/chats/{chatId}/voicememo`. For repeated sends of the same file, use
+    `attachment_id` to avoid redundant downloads.
+
+    Either `url` or `attachment_id` must be provided, but not both.
+    """

linq/types/message.py

@@ -0,0 +1,87 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import List, Union, Optional
+from datetime import datetime
+from typing_extensions import Literal, TypeAlias
+
+from pydantic import Field as FieldInfo
+
+from .._models import BaseModel
+from .reply_to import ReplyTo
+from .message_effect import MessageEffect
+from .shared.reaction import Reaction
+from .shared.chat_handle import ChatHandle
+from .shared.service_type import ServiceType
+from .shared.text_part_response import TextPartResponse
+from .shared.media_part_response import MediaPartResponse
+
+__all__ = ["Message", "Part", "PartLinkPartResponse"]
+
+
+class PartLinkPartResponse(BaseModel):
+    """A rich link preview part"""
+
+    reactions: Optional[List[Reaction]] = None
+    """Reactions on this message part"""
+
+    type: Literal["link"]
+    """Indicates this is a rich link preview part"""
+
+    value: str
+    """The URL"""
+
+
+Part: TypeAlias = Union[TextPartResponse, MediaPartResponse, PartLinkPartResponse]
+
+
+class Message(BaseModel):
+    id: str
+    """Unique identifier for the message"""
+
+    chat_id: str
+    """ID of the chat this message belongs to"""
+
+    created_at: datetime
+    """When the message was created"""
+
+    is_delivered: bool
+    """Whether the message has been delivered"""
+
+    is_from_me: bool
+    """Whether this message was sent by the authenticated user"""
+
+    is_read: bool
+    """Whether the message has been read"""
+
+    updated_at: datetime
+    """When the message was last updated"""
+
+    delivered_at: Optional[datetime] = None
+    """When the message was delivered"""
+
+    effect: Optional[MessageEffect] = None
+    """iMessage effect applied to a message (screen or bubble effect)"""
+
+    from_: Optional[str] = FieldInfo(alias="from", default=None)
+    """DEPRECATED: Use from_handle instead. Phone number of the message sender."""
+
+    from_handle: Optional[ChatHandle] = None
+    """The sender of this message as a full handle object"""
+
+    parts: Optional[List[Part]] = None
+    """Message parts in order (text, media, and link)"""
+
+    preferred_service: Optional[ServiceType] = None
+    """Messaging service type"""
+
+    read_at: Optional[datetime] = None
+    """When the message was read"""
+
+    reply_to: Optional[ReplyTo] = None
+    """Indicates this message is a threaded reply to another message"""
+
+    sent_at: Optional[datetime] = None
+    """When the message was sent"""
+
+    service: Optional[ServiceType] = None
+    """Messaging service type"""

linq/types/message_add_reaction_params.py

@@ -0,0 +1,32 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import Literal, Required, TypedDict
+
+from .shared.reaction_type import ReactionType
+
+__all__ = ["MessageAddReactionParams"]
+
+
+class MessageAddReactionParams(TypedDict, total=False):
+    operation: Required[Literal["add", "remove"]]
+    """Whether to add or remove the reaction"""
+
+    type: Required[ReactionType]
+    """Type of reaction.
+
+    Standard iMessage tapbacks are love, like, dislike, laugh, emphasize, question.
+    Custom emoji reactions have type "custom" with the actual emoji in the
+    custom_emoji field. Sticker reactions have type "sticker" with sticker
+    attachment details in the sticker field.
+    """
+
+    custom_emoji: str
+    """Custom emoji string. Required when type is "custom"."""
+
+    part_index: int
+    """
+    Optional index of the message part to react to. If not provided, reacts to the
+    entire message (part 0).
+    """

linq/types/message_add_reaction_response.py

@@ -0,0 +1,15 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+
+from .._models import BaseModel
+
+__all__ = ["MessageAddReactionResponse"]
+
+
+class MessageAddReactionResponse(BaseModel):
+    message: Optional[str] = None
+
+    status: Optional[str] = None
+
+    trace_id: Optional[str] = None

linq/types/message_content_param.py

@@ -0,0 +1,82 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing import Union, Iterable
+from typing_extensions import Required, TypeAlias, TypedDict
+
+from .reply_to_param import ReplyToParam
+from .link_part_param import LinkPartParam
+from .text_part_param import TextPartParam
+from .media_part_param import MediaPartParam
+from .shared.service_type import ServiceType
+from .message_effect_param import MessageEffectParam
+
+__all__ = ["MessageContentParam", "Part"]
+
+Part: TypeAlias = Union[TextPartParam, MediaPartParam, LinkPartParam]
+
+
+class MessageContentParam(TypedDict, total=False):
+    """Message content container.
+
+    Groups all message-related fields together,
+    separating the "what" (message content) from the "where" (routing fields like from/to).
+    """
+
+    parts: Required[Iterable[Part]]
+    """Array of message parts.
+
+    Each part can be text, media, or link. Parts are displayed in order. Text and
+    media can be mixed freely, but a `link` part must be the only part in the
+    message.
+
+    **Rich Link Previews:**
+
+    - Use a `link` part to send a URL with a rich preview card
+    - A `link` part must be the **only** part in the message
+    - To send a URL as plain text (no preview), use a `text` part instead
+
+    **Supported Media:**
+
+    - Images: .jpg, .jpeg, .png, .gif, .heic, .heif, .tif, .tiff, .bmp
+    - Videos: .mp4, .mov, .m4v, .mpeg, .mpg, .3gp
+    - Audio: .m4a, .mp3, .aac, .caf, .wav, .aiff, .amr
+    - Documents: .pdf, .txt, .rtf, .csv, .doc, .docx, .xls, .xlsx, .ppt, .pptx,
+      .pages, .numbers, .key, .epub, .zip, .html, .htm
+    - Contact & Calendar: .vcf, .ics
+
+    **Audio:**
+
+    - Audio files (.m4a, .mp3, .aac, .caf, .wav, .aiff, .amr) are fully supported as
+      media parts
+    - To send audio as an **iMessage voice memo bubble** (inline playback UI), use
+      the dedicated `/v3/chats/{chatId}/voicememo` endpoint instead
+
+    **Validation Rules:**
+
+    - A `link` part must be the **only** part in the message. It cannot be combined
+      with text or media parts.
+    - Consecutive text parts are not allowed. Text parts must be separated by media
+      parts. For example, [text, text] is invalid, but [text, media, text] is valid.
+    - Maximum of **100 parts** total.
+    - Media parts using a public `url` (downloaded by the server on send) are capped
+      at **40**. Parts using `attachment_id` or presigned URLs are exempt from this
+      sub-limit. For bulk media sends exceeding 40 files, pre-upload via
+      `POST /v3/attachments` and reference by `attachment_id` or `download_url`.
+    """
+
+    effect: MessageEffectParam
+    """iMessage effect to apply to this message (screen or bubble effect)"""
+
+    idempotency_key: str
+    """
+    Optional idempotency key for this message. Use this to prevent duplicate sends
+    of the same message.
+    """
+
+    preferred_service: ServiceType
+    """Messaging service type"""
+
+    reply_to: ReplyToParam
+    """Reply to another message to create a threaded conversation"""

linq/types/message_delivered_webhook_event.py

@@ -0,0 +1,65 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from datetime import datetime
+
+from .._models import BaseModel
+from .message_event_v2 import MessageEventV2
+from .webhook_event_type import WebhookEventType
+
+__all__ = ["MessageDeliveredWebhookEvent"]
+
+
+class MessageDeliveredWebhookEvent(BaseModel):
+    """Complete webhook payload for message.delivered events (2026-02-03 format)"""
+
+    api_version: str
+    """API version for the webhook payload format"""
+
+    created_at: datetime
+    """When the event was created"""
+
+    data: MessageEventV2
+    """Unified payload for message webhooks when using `webhook_version: "2026-02-03"`.
+
+    This schema is used for message.sent, message.received, message.delivered, and
+    message.read events when the subscription URL includes `?version=2026-02-03`.
+
+    Key differences from V1 (2025-01-01):
+
+    - `direction`: "inbound" or "outbound" instead of `is_from_me` boolean
+    - `sender_handle`: Full handle object for the sender
+    - `chat`: Nested object with `id`, `is_group`, and `owner_handle`
+    - Message fields (`id`, `parts`, `effect`, etc.) are at the top level, not
+      nested in `message`
+
+    Timestamps indicate the message state:
+
+    - `message.sent`: sent_at set, delivered_at=null, read_at=null
+    - `message.received`: sent_at set, delivered_at=null, read_at=null
+    - `message.delivered`: sent_at set, delivered_at set, read_at=null
+    - `message.read`: sent_at set, delivered_at set, read_at set
+    """
+
+    event_id: str
+    """Unique identifier for this event (for deduplication)"""
+
+    event_type: WebhookEventType
+    """Valid webhook event types that can be subscribed to.
+
+    **Note:** `message.edited` is only delivered to subscriptions using
+    `webhook_version: "2026-02-03"`. Subscribing to this event on a v2025
+    subscription will not produce any deliveries.
+    """
+
+    partner_id: str
+    """Partner identifier. Present on all webhooks for cross-referencing."""
+
+    trace_id: str
+    """Trace ID for debugging and correlation across systems."""
+
+    webhook_version: str
+    """
+    Date-based webhook payload version. Determined by the `?version=` query
+    parameter in your webhook subscription URL. If no version parameter is
+    specified, defaults based on subscription creation date.
+    """

linq/types/message_edited_webhook_event.py

@@ -0,0 +1,100 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from datetime import datetime
+from typing_extensions import Literal
+
+from .._models import BaseModel
+from .shared.chat_handle import ChatHandle
+from .webhook_event_type import WebhookEventType
+
+__all__ = ["MessageEditedWebhookEvent", "Data", "DataChat", "DataPart"]
+
+
+class DataChat(BaseModel):
+    """Chat context"""
+
+    id: str
+    """Chat identifier"""
+
+    is_group: bool
+    """Whether this is a group chat"""
+
+    owner_handle: ChatHandle
+    """The handle that owns this chat (your phone number)"""
+
+
+class DataPart(BaseModel):
+    """The edited part"""
+
+    index: int
+    """Zero-based index of the edited part within the message"""
+
+    text: str
+    """New text content of the part"""
+
+
+class Data(BaseModel):
+    """Payload for `message.edited` events (2026-02-03 format).
+
+    Describes which part of a message was edited and when. Only text parts can be edited.
+    Only available for subscriptions using `webhook_version: "2026-02-03"`.
+    """
+
+    id: str
+    """Message identifier"""
+
+    chat: DataChat
+    """Chat context"""
+
+    direction: Literal["outbound", "inbound"]
+    """\"outbound" if you sent the original message, "inbound" if you received it"""
+
+    edited_at: datetime
+    """When the edit occurred"""
+
+    part: DataPart
+    """The edited part"""
+
+    sender_handle: ChatHandle
+    """The handle that sent (and edited) this message"""
+
+
+class MessageEditedWebhookEvent(BaseModel):
+    """Complete webhook payload for message.edited events (2026-02-03 format only)"""
+
+    api_version: str
+    """API version for the webhook payload format"""
+
+    created_at: datetime
+    """When the event was created"""
+
+    data: Data
+    """Payload for `message.edited` events (2026-02-03 format).
+
+    Describes which part of a message was edited and when. Only text parts can be
+    edited. Only available for subscriptions using `webhook_version: "2026-02-03"`.
+    """
+
+    event_id: str
+    """Unique identifier for this event (for deduplication)"""
+
+    event_type: WebhookEventType
+    """Valid webhook event types that can be subscribed to.
+
+    **Note:** `message.edited` is only delivered to subscriptions using
+    `webhook_version: "2026-02-03"`. Subscribing to this event on a v2025
+    subscription will not produce any deliveries.
+    """
+
+    partner_id: str
+    """Partner identifier. Present on all webhooks for cross-referencing."""
+
+    trace_id: str
+    """Trace ID for debugging and correlation across systems."""
+
+    webhook_version: str
+    """
+    Date-based webhook payload version. Determined by the `?version=` query
+    parameter in your webhook subscription URL. If no version parameter is
+    specified, defaults based on subscription creation date.
+    """

linq/types/message_effect.py

@@ -0,0 +1,23 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from typing import Optional
+from typing_extensions import Literal
+
+from .._models import BaseModel
+
+__all__ = ["MessageEffect"]
+
+
+class MessageEffect(BaseModel):
+    """iMessage effect applied to a message (screen or bubble effect)"""
+
+    name: Optional[str] = None
+    """Name of the effect. Common values:
+
+    - Screen effects: confetti, fireworks, lasers, sparkles, celebration, hearts,
+      love, balloons, happy_birthday, echo, spotlight
+    - Bubble effects: slam, loud, gentle, invisible
+    """
+
+    type: Optional[Literal["screen", "bubble"]] = None
+    """Type of effect"""

linq/types/message_effect_param.py

@@ -0,0 +1,22 @@
+# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
+
+from __future__ import annotations
+
+from typing_extensions import Literal, TypedDict
+
+__all__ = ["MessageEffectParam"]
+
+
+class MessageEffectParam(TypedDict, total=False):
+    """iMessage effect applied to a message (screen or bubble effect)"""
+
+    name: str
+    """Name of the effect. Common values:
+
+    - Screen effects: confetti, fireworks, lasers, sparkles, celebration, hearts,
+      love, balloons, happy_birthday, echo, spotlight
+    - Bubble effects: slam, loud, gentle, invisible
+    """
+
+    type: Literal["screen", "bubble"]
+    """Type of effect"""