linq-python 0.15.0__tar.gz → 0.15.1__tar.gz

linq_python-0.15.1/.release-please-manifest.json

@@ -0,0 +1,3 @@
+{
+  ".": "0.15.1"
+}

{linq_python-0.15.0 → linq_python-0.15.1}/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## [0.15.1](https://github.com/linq-team/linq-python/compare/v0.15.0...v0.15.1) (2026-07-06)
+
+
+### Documentation
+
+* clarify phone line reputation status descriptions ([#34](https://github.com/linq-team/linq-python/issues/34)) ([a5a6a99](https://github.com/linq-team/linq-python/commit/a5a6a99e2a66bacd6f50b36155d8ffb152a4a85a))
+
 ## [0.15.0](https://github.com/linq-team/linq-python/compare/v0.14.0...v0.15.0) (2026-06-21)
 
 

{linq_python-0.15.0 → linq_python-0.15.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: linq-python
-Version: 0.15.0
+Version: 0.15.1
 Summary: The official Python library for the linq-api-v3 API
 Project-URL: Homepage, https://github.com/linq-team/linq-python
 Project-URL: Repository, https://github.com/linq-team/linq-python

{linq_python-0.15.0 → linq_python-0.15.1}/api.md

@@ -93,16 +93,25 @@ Methods:
 Types:
 
 ```python
-from linq.types import Message, MessageEffect, ReplyTo, MessageAddReactionResponse
+from linq.types import (
+    Message,
+    MessageEffect,
+    ReplyTo,
+    MessageCreateResponse,
+    MessageAddReactionResponse,
+    MessageUpdateAppCardResponse,
+)
 ```
 
 Methods:
 
+- <code title="post /v3/messages">client.messages.<a href="./src/linq/resources/messages.py">create</a>(\*\*<a href="src/linq/types/message_create_params.py">params</a>) -> <a href="./src/linq/types/message_create_response.py">MessageCreateResponse</a></code>
 - <code title="get /v3/messages/{messageId}">client.messages.<a href="./src/linq/resources/messages.py">retrieve</a>(message_id) -> <a href="./src/linq/types/message.py">Message</a></code>
 - <code title="patch /v3/messages/{messageId}">client.messages.<a href="./src/linq/resources/messages.py">update</a>(message_id, \*\*<a href="src/linq/types/message_update_params.py">params</a>) -> <a href="./src/linq/types/message.py">Message</a></code>
 - <code title="delete /v3/messages/{messageId}">client.messages.<a href="./src/linq/resources/messages.py">delete</a>(message_id) -> None</code>
 - <code title="post /v3/messages/{messageId}/reactions">client.messages.<a href="./src/linq/resources/messages.py">add_reaction</a>(message_id, \*\*<a href="src/linq/types/message_add_reaction_params.py">params</a>) -> <a href="./src/linq/types/message_add_reaction_response.py">MessageAddReactionResponse</a></code>
 - <code title="get /v3/messages/{messageId}/thread">client.messages.<a href="./src/linq/resources/messages.py">list_messages_thread</a>(message_id, \*\*<a href="src/linq/types/message_list_messages_thread_params.py">params</a>) -> <a href="./src/linq/types/message.py">SyncListMessagesPagination[Message]</a></code>
+- <code title="post /v3/messages/{messageId}/update">client.messages.<a href="./src/linq/resources/messages.py">update_app_card</a>(message_id, \*\*<a href="src/linq/types/message_update_app_card_params.py">params</a>) -> <a href="./src/linq/types/message_update_app_card_response.py">MessageUpdateAppCardResponse</a></code>
 
 # Attachments
 
@@ -135,13 +144,26 @@ Methods:
 Types:
 
 ```python
-from linq.types import PhoneNumberListResponse
+from linq.types import PhoneNumberUpdateResponse, PhoneNumberListResponse
 ```
 
 Methods:
 
+- <code title="put /v3/phone_numbers/{phoneNumberId}">client.phone_numbers.<a href="./src/linq/resources/phone_numbers.py">update</a>(phone_number_id, \*\*<a href="src/linq/types/phone_number_update_params.py">params</a>) -> <a href="./src/linq/types/phone_number_update_response.py">PhoneNumberUpdateResponse</a></code>
 - <code title="get /v3/phone_numbers">client.phone_numbers.<a href="./src/linq/resources/phone_numbers.py">list</a>() -> <a href="./src/linq/types/phone_number_list_response.py">PhoneNumberListResponse</a></code>
 
+# AvailableNumber
+
+Types:
+
+```python
+from linq.types import AvailableNumberRetrieveResponse
+```
+
+Methods:
+
+- <code title="get /v3/available_number">client.available_number.<a href="./src/linq/resources/available_number.py">retrieve</a>(\*\*<a href="src/linq/types/available_number_retrieve_params.py">params</a>) -> <a href="./src/linq/types/available_number_retrieve_response.py">AvailableNumberRetrieveResponse</a></code>
+
 # WebhookEvents
 
 Types:

{linq_python-0.15.0 → linq_python-0.15.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "linq-python"
-version = "0.15.0"
+version = "0.15.1"
 description = "The official Python library for the linq-api-v3 API"
 dynamic = ["readme"]
 license = "Apache-2.0"

{linq_python-0.15.0 → linq_python-0.15.1}/src/linq/_client.py

@@ -45,6 +45,7 @@ if TYPE_CHECKING:
         phonenumbers,
         phone_numbers,
         webhook_events,
+        available_number,
         webhook_subscriptions,
     )
     from .resources.messages import MessagesResource, AsyncMessagesResource
@@ -56,6 +57,7 @@ if TYPE_CHECKING:
     from .resources.phonenumbers import PhonenumbersResource, AsyncPhonenumbersResource
     from .resources.phone_numbers import PhoneNumbersResource, AsyncPhoneNumbersResource
     from .resources.webhook_events import WebhookEventsResource, AsyncWebhookEventsResource
+    from .resources.available_number import AvailableNumberResource, AsyncAvailableNumberResource
     from .resources.webhook_subscriptions import WebhookSubscriptionsResource, AsyncWebhookSubscriptionsResource
 
 __all__ = [
@@ -168,6 +170,46 @@ class LinqAPIV3(SyncAPIClient):
         **Limitations:**
         - A `link` part cannot be combined with other parts in the same message.
         - Maximum URL length: 2,048 characters.
+
+        ## Ephemeral Messages (Privacy Tier)
+
+        For regulated or sensitive conversations, opt in to the **ephemeral messages** tier by contacting your Linq support contact. When enabled, every message on the covered phone numbers is automatically given a fixed **24-hour retention window** — after that window the platform permanently deletes the message from Linq storage. There is no per-message flag; ephemerality is applied automatically based on your configuration.
+
+        You can request it at two scopes:
+
+        | Scope | Effect |
+        |---|---|
+        | **Partner-wide** | Every outbound and inbound message on every phone number under your account is retained for 24 hours, then deleted. |
+        | **Per phone number** | Only the specified phone numbers have their messages auto-deleted. The rest follow the standard message-retention policy. |
+
+        **Behavioral differences vs the standard default:**
+
+        | Aspect | Standard | Ephemeral |
+        |---|---|---|
+        | Retention | Retained per the standard message-retention policy | **Hard backstop: 24 hours** from when the message is created |
+        | After expiry | Message stays retrievable | Message is permanently deleted — `GET /v3/messages/{messageId}` returns `404` and it no longer appears in `GET /v3/chats/{chatId}/messages` |
+        | Content on expiry | N/A | Text, formatting, and attachment references are scrubbed; the message is gone, not blanked out |
+        | Cross-partner isolation | Enforced | Enforced |
+
+        **How the 24-hour window works:**
+
+        - The window is fixed at **24 hours from message creation** (`created_at`) and cannot be configured per message.
+        - It mirrors the ephemeral *attachments* 1-day backstop, so a message and any media it carries expire together.
+        - Expiry is delivery-independent — the clock starts when the message is created, not when it is delivered or read.
+
+        **What you observe:**
+
+        - **No expiry timestamp is exposed.** API responses and webhook payloads do not include the deletion time. If you need it, compute `created_at + 24h` yourself.
+        - **No deletion webhook is sent.** There is no `message.deleted` event — a message simply stops being retrievable once its window passes.
+        - **Delivery is unaffected.** Ephemeral messages send, deliver, and fire the usual `message.sent` / `message.received` and status webhooks exactly like standard messages. Only retention changes.
+
+        **When to choose ephemeral:**
+
+        - You have a compliance requirement that the platform must not retain message content beyond a short window.
+        - The conversation is high-sensitivity (PHI, financial, identity verification) and you do not want it sitting in storage long-term.
+        - Your application is the system of record — you capture what you need from the delivery webhook in real time and do not rely on reading message history back from Linq later.
+
+        **Important:** ephemeral applies in *both directions* — messages you send **and** messages received by the phone numbers in that scope. Because Linq can no longer return the message after 24 hours, persist anything you need to keep from the webhook payload at the time it is delivered.
         """
         from .resources.messages import MessagesResource
 
@@ -339,7 +381,7 @@ class LinqAPIV3(SyncAPIClient):
         |---|---|---|
         | Attachment bytes | Retained until you `DELETE` | **Auto-removed after 1 day**, also removable via `DELETE` |
         | Attachment metadata (id, filename, mime type, size) | Retained until you `DELETE` | Removed alongside the bytes |
-        | Message body & parts | Retained per message-retention policy | Retained per message-retention policy |
+        | Message body & parts | Retained per message-retention policy | Retained per message-retention policy — unless the line also has **ephemeral messages** enabled (see the Messages page), in which case the message and its parts are deleted 24 hours after creation |
         | Audit log of deletions | Retained per platform retention policy | Retained per platform retention policy |
 
         **In transit:** TLS 1.2+ everywhere. **At rest:** AES-256 (server-side encryption).
@@ -387,6 +429,20 @@ class LinqAPIV3(SyncAPIClient):
 
         return PhoneNumbersResource(self)
 
+    @cached_property
+    def available_number(self) -> AvailableNumberResource:
+        """Phone Numbers represent the phone numbers assigned to your partner account.
+
+        Use the list phone numbers endpoint to discover which phone numbers are available
+        for sending messages.
+
+        When creating chats, listing chats, or sending a voice memo, use one of your assigned phone numbers
+        in the `from` field.
+        """
+        from .resources.available_number import AvailableNumberResource
+
+        return AvailableNumberResource(self)
+
     @cached_property
     def webhook_events(self) -> WebhookEventsResource:
         """
@@ -698,9 +754,11 @@ class LinqAPIV3(SyncAPIClient):
 
     @override
     def _auth_headers(self, security: SecurityOptions) -> dict[str, str]:
-        return {
-            **(self._bearer_auth if security.get("bearer_auth", False) else {}),
-        }
+        headers: dict[str, str] = {}
+        if security.get("bearer_auth", False):
+            for key, value in self._bearer_auth.items():
+                headers.setdefault(key, value)
+        return headers
 
     @property
     def _bearer_auth(self) -> dict[str, str]:
@@ -901,6 +959,46 @@ class AsyncLinqAPIV3(AsyncAPIClient):
         **Limitations:**
         - A `link` part cannot be combined with other parts in the same message.
         - Maximum URL length: 2,048 characters.
+
+        ## Ephemeral Messages (Privacy Tier)
+
+        For regulated or sensitive conversations, opt in to the **ephemeral messages** tier by contacting your Linq support contact. When enabled, every message on the covered phone numbers is automatically given a fixed **24-hour retention window** — after that window the platform permanently deletes the message from Linq storage. There is no per-message flag; ephemerality is applied automatically based on your configuration.
+
+        You can request it at two scopes:
+
+        | Scope | Effect |
+        |---|---|
+        | **Partner-wide** | Every outbound and inbound message on every phone number under your account is retained for 24 hours, then deleted. |
+        | **Per phone number** | Only the specified phone numbers have their messages auto-deleted. The rest follow the standard message-retention policy. |
+
+        **Behavioral differences vs the standard default:**
+
+        | Aspect | Standard | Ephemeral |
+        |---|---|---|
+        | Retention | Retained per the standard message-retention policy | **Hard backstop: 24 hours** from when the message is created |
+        | After expiry | Message stays retrievable | Message is permanently deleted — `GET /v3/messages/{messageId}` returns `404` and it no longer appears in `GET /v3/chats/{chatId}/messages` |
+        | Content on expiry | N/A | Text, formatting, and attachment references are scrubbed; the message is gone, not blanked out |
+        | Cross-partner isolation | Enforced | Enforced |
+
+        **How the 24-hour window works:**
+
+        - The window is fixed at **24 hours from message creation** (`created_at`) and cannot be configured per message.
+        - It mirrors the ephemeral *attachments* 1-day backstop, so a message and any media it carries expire together.
+        - Expiry is delivery-independent — the clock starts when the message is created, not when it is delivered or read.
+
+        **What you observe:**
+
+        - **No expiry timestamp is exposed.** API responses and webhook payloads do not include the deletion time. If you need it, compute `created_at + 24h` yourself.
+        - **No deletion webhook is sent.** There is no `message.deleted` event — a message simply stops being retrievable once its window passes.
+        - **Delivery is unaffected.** Ephemeral messages send, deliver, and fire the usual `message.sent` / `message.received` and status webhooks exactly like standard messages. Only retention changes.
+
+        **When to choose ephemeral:**
+
+        - You have a compliance requirement that the platform must not retain message content beyond a short window.
+        - The conversation is high-sensitivity (PHI, financial, identity verification) and you do not want it sitting in storage long-term.
+        - Your application is the system of record — you capture what you need from the delivery webhook in real time and do not rely on reading message history back from Linq later.
+
+        **Important:** ephemeral applies in *both directions* — messages you send **and** messages received by the phone numbers in that scope. Because Linq can no longer return the message after 24 hours, persist anything you need to keep from the webhook payload at the time it is delivered.
         """
         from .resources.messages import AsyncMessagesResource
 
@@ -1072,7 +1170,7 @@ class AsyncLinqAPIV3(AsyncAPIClient):
         |---|---|---|
         | Attachment bytes | Retained until you `DELETE` | **Auto-removed after 1 day**, also removable via `DELETE` |
         | Attachment metadata (id, filename, mime type, size) | Retained until you `DELETE` | Removed alongside the bytes |
-        | Message body & parts | Retained per message-retention policy | Retained per message-retention policy |
+        | Message body & parts | Retained per message-retention policy | Retained per message-retention policy — unless the line also has **ephemeral messages** enabled (see the Messages page), in which case the message and its parts are deleted 24 hours after creation |
         | Audit log of deletions | Retained per platform retention policy | Retained per platform retention policy |
 
         **In transit:** TLS 1.2+ everywhere. **At rest:** AES-256 (server-side encryption).
@@ -1120,6 +1218,20 @@ class AsyncLinqAPIV3(AsyncAPIClient):
 
         return AsyncPhoneNumbersResource(self)
 
+    @cached_property
+    def available_number(self) -> AsyncAvailableNumberResource:
+        """Phone Numbers represent the phone numbers assigned to your partner account.
+
+        Use the list phone numbers endpoint to discover which phone numbers are available
+        for sending messages.
+
+        When creating chats, listing chats, or sending a voice memo, use one of your assigned phone numbers
+        in the `from` field.
+        """
+        from .resources.available_number import AsyncAvailableNumberResource
+
+        return AsyncAvailableNumberResource(self)
+
     @cached_property
     def webhook_events(self) -> AsyncWebhookEventsResource:
         """
@@ -1431,9 +1543,11 @@ class AsyncLinqAPIV3(AsyncAPIClient):
 
     @override
     def _auth_headers(self, security: SecurityOptions) -> dict[str, str]:
-        return {
-            **(self._bearer_auth if security.get("bearer_auth", False) else {}),
-        }
+        headers: dict[str, str] = {}
+        if security.get("bearer_auth", False):
+            for key, value in self._bearer_auth.items():
+                headers.setdefault(key, value)
+        return headers
 
     @property
     def _bearer_auth(self) -> dict[str, str]:
@@ -1568,6 +1682,46 @@ class LinqAPIV3WithRawResponse:
         **Limitations:**
         - A `link` part cannot be combined with other parts in the same message.
         - Maximum URL length: 2,048 characters.
+
+        ## Ephemeral Messages (Privacy Tier)
+
+        For regulated or sensitive conversations, opt in to the **ephemeral messages** tier by contacting your Linq support contact. When enabled, every message on the covered phone numbers is automatically given a fixed **24-hour retention window** — after that window the platform permanently deletes the message from Linq storage. There is no per-message flag; ephemerality is applied automatically based on your configuration.
+
+        You can request it at two scopes:
+
+        | Scope | Effect |
+        |---|---|
+        | **Partner-wide** | Every outbound and inbound message on every phone number under your account is retained for 24 hours, then deleted. |
+        | **Per phone number** | Only the specified phone numbers have their messages auto-deleted. The rest follow the standard message-retention policy. |
+
+        **Behavioral differences vs the standard default:**
+
+        | Aspect | Standard | Ephemeral |
+        |---|---|---|
+        | Retention | Retained per the standard message-retention policy | **Hard backstop: 24 hours** from when the message is created |
+        | After expiry | Message stays retrievable | Message is permanently deleted — `GET /v3/messages/{messageId}` returns `404` and it no longer appears in `GET /v3/chats/{chatId}/messages` |
+        | Content on expiry | N/A | Text, formatting, and attachment references are scrubbed; the message is gone, not blanked out |
+        | Cross-partner isolation | Enforced | Enforced |
+
+        **How the 24-hour window works:**
+
+        - The window is fixed at **24 hours from message creation** (`created_at`) and cannot be configured per message.
+        - It mirrors the ephemeral *attachments* 1-day backstop, so a message and any media it carries expire together.
+        - Expiry is delivery-independent — the clock starts when the message is created, not when it is delivered or read.
+
+        **What you observe:**
+
+        - **No expiry timestamp is exposed.** API responses and webhook payloads do not include the deletion time. If you need it, compute `created_at + 24h` yourself.
+        - **No deletion webhook is sent.** There is no `message.deleted` event — a message simply stops being retrievable once its window passes.
+        - **Delivery is unaffected.** Ephemeral messages send, deliver, and fire the usual `message.sent` / `message.received` and status webhooks exactly like standard messages. Only retention changes.
+
+        **When to choose ephemeral:**
+
+        - You have a compliance requirement that the platform must not retain message content beyond a short window.
+        - The conversation is high-sensitivity (PHI, financial, identity verification) and you do not want it sitting in storage long-term.
+        - Your application is the system of record — you capture what you need from the delivery webhook in real time and do not rely on reading message history back from Linq later.
+
+        **Important:** ephemeral applies in *both directions* — messages you send **and** messages received by the phone numbers in that scope. Because Linq can no longer return the message after 24 hours, persist anything you need to keep from the webhook payload at the time it is delivered.
         """
         from .resources.messages import MessagesResourceWithRawResponse
 
@@ -1739,7 +1893,7 @@ class LinqAPIV3WithRawResponse:
         |---|---|---|
         | Attachment bytes | Retained until you `DELETE` | **Auto-removed after 1 day**, also removable via `DELETE` |
         | Attachment metadata (id, filename, mime type, size) | Retained until you `DELETE` | Removed alongside the bytes |
-        | Message body & parts | Retained per message-retention policy | Retained per message-retention policy |
+        | Message body & parts | Retained per message-retention policy | Retained per message-retention policy — unless the line also has **ephemeral messages** enabled (see the Messages page), in which case the message and its parts are deleted 24 hours after creation |
         | Audit log of deletions | Retained per platform retention policy | Retained per platform retention policy |
 
         **In transit:** TLS 1.2+ everywhere. **At rest:** AES-256 (server-side encryption).
@@ -1787,6 +1941,20 @@ class LinqAPIV3WithRawResponse:
 
         return PhoneNumbersResourceWithRawResponse(self._client.phone_numbers)
 
+    @cached_property
+    def available_number(self) -> available_number.AvailableNumberResourceWithRawResponse:
+        """Phone Numbers represent the phone numbers assigned to your partner account.
+
+        Use the list phone numbers endpoint to discover which phone numbers are available
+        for sending messages.
+
+        When creating chats, listing chats, or sending a voice memo, use one of your assigned phone numbers
+        in the `from` field.
+        """
+        from .resources.available_number import AvailableNumberResourceWithRawResponse
+
+        return AvailableNumberResourceWithRawResponse(self._client.available_number)
+
     @cached_property
     def webhook_events(self) -> webhook_events.WebhookEventsResourceWithRawResponse:
         """
@@ -2110,6 +2278,46 @@ class AsyncLinqAPIV3WithRawResponse:
         **Limitations:**
         - A `link` part cannot be combined with other parts in the same message.
         - Maximum URL length: 2,048 characters.
+
+        ## Ephemeral Messages (Privacy Tier)
+
+        For regulated or sensitive conversations, opt in to the **ephemeral messages** tier by contacting your Linq support contact. When enabled, every message on the covered phone numbers is automatically given a fixed **24-hour retention window** — after that window the platform permanently deletes the message from Linq storage. There is no per-message flag; ephemerality is applied automatically based on your configuration.
+
+        You can request it at two scopes:
+
+        | Scope | Effect |
+        |---|---|
+        | **Partner-wide** | Every outbound and inbound message on every phone number under your account is retained for 24 hours, then deleted. |
+        | **Per phone number** | Only the specified phone numbers have their messages auto-deleted. The rest follow the standard message-retention policy. |
+
+        **Behavioral differences vs the standard default:**
+
+        | Aspect | Standard | Ephemeral |
+        |---|---|---|
+        | Retention | Retained per the standard message-retention policy | **Hard backstop: 24 hours** from when the message is created |
+        | After expiry | Message stays retrievable | Message is permanently deleted — `GET /v3/messages/{messageId}` returns `404` and it no longer appears in `GET /v3/chats/{chatId}/messages` |
+        | Content on expiry | N/A | Text, formatting, and attachment references are scrubbed; the message is gone, not blanked out |
+        | Cross-partner isolation | Enforced | Enforced |
+
+        **How the 24-hour window works:**
+
+        - The window is fixed at **24 hours from message creation** (`created_at`) and cannot be configured per message.
+        - It mirrors the ephemeral *attachments* 1-day backstop, so a message and any media it carries expire together.
+        - Expiry is delivery-independent — the clock starts when the message is created, not when it is delivered or read.
+
+        **What you observe:**
+
+        - **No expiry timestamp is exposed.** API responses and webhook payloads do not include the deletion time. If you need it, compute `created_at + 24h` yourself.
+        - **No deletion webhook is sent.** There is no `message.deleted` event — a message simply stops being retrievable once its window passes.
+        - **Delivery is unaffected.** Ephemeral messages send, deliver, and fire the usual `message.sent` / `message.received` and status webhooks exactly like standard messages. Only retention changes.
+
+        **When to choose ephemeral:**
+
+        - You have a compliance requirement that the platform must not retain message content beyond a short window.
+        - The conversation is high-sensitivity (PHI, financial, identity verification) and you do not want it sitting in storage long-term.
+        - Your application is the system of record — you capture what you need from the delivery webhook in real time and do not rely on reading message history back from Linq later.
+
+        **Important:** ephemeral applies in *both directions* — messages you send **and** messages received by the phone numbers in that scope. Because Linq can no longer return the message after 24 hours, persist anything you need to keep from the webhook payload at the time it is delivered.
         """
         from .resources.messages import AsyncMessagesResourceWithRawResponse
 
@@ -2281,7 +2489,7 @@ class AsyncLinqAPIV3WithRawResponse:
         |---|---|---|
         | Attachment bytes | Retained until you `DELETE` | **Auto-removed after 1 day**, also removable via `DELETE` |
         | Attachment metadata (id, filename, mime type, size) | Retained until you `DELETE` | Removed alongside the bytes |
-        | Message body & parts | Retained per message-retention policy | Retained per message-retention policy |
+        | Message body & parts | Retained per message-retention policy | Retained per message-retention policy — unless the line also has **ephemeral messages** enabled (see the Messages page), in which case the message and its parts are deleted 24 hours after creation |
         | Audit log of deletions | Retained per platform retention policy | Retained per platform retention policy |
 
         **In transit:** TLS 1.2+ everywhere. **At rest:** AES-256 (server-side encryption).
@@ -2329,6 +2537,20 @@ class AsyncLinqAPIV3WithRawResponse:
 
         return AsyncPhoneNumbersResourceWithRawResponse(self._client.phone_numbers)
 
+    @cached_property
+    def available_number(self) -> available_number.AsyncAvailableNumberResourceWithRawResponse:
+        """Phone Numbers represent the phone numbers assigned to your partner account.
+
+        Use the list phone numbers endpoint to discover which phone numbers are available
+        for sending messages.
+
+        When creating chats, listing chats, or sending a voice memo, use one of your assigned phone numbers
+        in the `from` field.
+        """
+        from .resources.available_number import AsyncAvailableNumberResourceWithRawResponse
+
+        return AsyncAvailableNumberResourceWithRawResponse(self._client.available_number)
+
     @cached_property
     def webhook_events(self) -> webhook_events.AsyncWebhookEventsResourceWithRawResponse:
         """
@@ -2652,6 +2874,46 @@ class LinqAPIV3WithStreamedResponse:
         **Limitations:**
         - A `link` part cannot be combined with other parts in the same message.
         - Maximum URL length: 2,048 characters.
+
+        ## Ephemeral Messages (Privacy Tier)
+
+        For regulated or sensitive conversations, opt in to the **ephemeral messages** tier by contacting your Linq support contact. When enabled, every message on the covered phone numbers is automatically given a fixed **24-hour retention window** — after that window the platform permanently deletes the message from Linq storage. There is no per-message flag; ephemerality is applied automatically based on your configuration.
+
+        You can request it at two scopes:
+
+        | Scope | Effect |
+        |---|---|
+        | **Partner-wide** | Every outbound and inbound message on every phone number under your account is retained for 24 hours, then deleted. |
+        | **Per phone number** | Only the specified phone numbers have their messages auto-deleted. The rest follow the standard message-retention policy. |
+
+        **Behavioral differences vs the standard default:**
+
+        | Aspect | Standard | Ephemeral |
+        |---|---|---|
+        | Retention | Retained per the standard message-retention policy | **Hard backstop: 24 hours** from when the message is created |
+        | After expiry | Message stays retrievable | Message is permanently deleted — `GET /v3/messages/{messageId}` returns `404` and it no longer appears in `GET /v3/chats/{chatId}/messages` |
+        | Content on expiry | N/A | Text, formatting, and attachment references are scrubbed; the message is gone, not blanked out |
+        | Cross-partner isolation | Enforced | Enforced |
+
+        **How the 24-hour window works:**
+
+        - The window is fixed at **24 hours from message creation** (`created_at`) and cannot be configured per message.
+        - It mirrors the ephemeral *attachments* 1-day backstop, so a message and any media it carries expire together.
+        - Expiry is delivery-independent — the clock starts when the message is created, not when it is delivered or read.
+
+        **What you observe:**
+
+        - **No expiry timestamp is exposed.** API responses and webhook payloads do not include the deletion time. If you need it, compute `created_at + 24h` yourself.
+        - **No deletion webhook is sent.** There is no `message.deleted` event — a message simply stops being retrievable once its window passes.
+        - **Delivery is unaffected.** Ephemeral messages send, deliver, and fire the usual `message.sent` / `message.received` and status webhooks exactly like standard messages. Only retention changes.
+
+        **When to choose ephemeral:**
+
+        - You have a compliance requirement that the platform must not retain message content beyond a short window.
+        - The conversation is high-sensitivity (PHI, financial, identity verification) and you do not want it sitting in storage long-term.
+        - Your application is the system of record — you capture what you need from the delivery webhook in real time and do not rely on reading message history back from Linq later.
+
+        **Important:** ephemeral applies in *both directions* — messages you send **and** messages received by the phone numbers in that scope. Because Linq can no longer return the message after 24 hours, persist anything you need to keep from the webhook payload at the time it is delivered.
         """
         from .resources.messages import MessagesResourceWithStreamingResponse
 
@@ -2823,7 +3085,7 @@ class LinqAPIV3WithStreamedResponse:
         |---|---|---|
         | Attachment bytes | Retained until you `DELETE` | **Auto-removed after 1 day**, also removable via `DELETE` |
         | Attachment metadata (id, filename, mime type, size) | Retained until you `DELETE` | Removed alongside the bytes |
-        | Message body & parts | Retained per message-retention policy | Retained per message-retention policy |
+        | Message body & parts | Retained per message-retention policy | Retained per message-retention policy — unless the line also has **ephemeral messages** enabled (see the Messages page), in which case the message and its parts are deleted 24 hours after creation |
         | Audit log of deletions | Retained per platform retention policy | Retained per platform retention policy |
 
         **In transit:** TLS 1.2+ everywhere. **At rest:** AES-256 (server-side encryption).
@@ -2871,6 +3133,20 @@ class LinqAPIV3WithStreamedResponse:
 
         return PhoneNumbersResourceWithStreamingResponse(self._client.phone_numbers)
 
+    @cached_property
+    def available_number(self) -> available_number.AvailableNumberResourceWithStreamingResponse:
+        """Phone Numbers represent the phone numbers assigned to your partner account.
+
+        Use the list phone numbers endpoint to discover which phone numbers are available
+        for sending messages.
+
+        When creating chats, listing chats, or sending a voice memo, use one of your assigned phone numbers
+        in the `from` field.
+        """
+        from .resources.available_number import AvailableNumberResourceWithStreamingResponse
+
+        return AvailableNumberResourceWithStreamingResponse(self._client.available_number)
+
     @cached_property
     def webhook_events(self) -> webhook_events.WebhookEventsResourceWithStreamingResponse:
         """
@@ -3194,6 +3470,46 @@ class AsyncLinqAPIV3WithStreamedResponse:
         **Limitations:**
         - A `link` part cannot be combined with other parts in the same message.
         - Maximum URL length: 2,048 characters.
+
+        ## Ephemeral Messages (Privacy Tier)
+
+        For regulated or sensitive conversations, opt in to the **ephemeral messages** tier by contacting your Linq support contact. When enabled, every message on the covered phone numbers is automatically given a fixed **24-hour retention window** — after that window the platform permanently deletes the message from Linq storage. There is no per-message flag; ephemerality is applied automatically based on your configuration.
+
+        You can request it at two scopes:
+
+        | Scope | Effect |
+        |---|---|
+        | **Partner-wide** | Every outbound and inbound message on every phone number under your account is retained for 24 hours, then deleted. |
+        | **Per phone number** | Only the specified phone numbers have their messages auto-deleted. The rest follow the standard message-retention policy. |
+
+        **Behavioral differences vs the standard default:**
+
+        | Aspect | Standard | Ephemeral |
+        |---|---|---|
+        | Retention | Retained per the standard message-retention policy | **Hard backstop: 24 hours** from when the message is created |
+        | After expiry | Message stays retrievable | Message is permanently deleted — `GET /v3/messages/{messageId}` returns `404` and it no longer appears in `GET /v3/chats/{chatId}/messages` |
+        | Content on expiry | N/A | Text, formatting, and attachment references are scrubbed; the message is gone, not blanked out |
+        | Cross-partner isolation | Enforced | Enforced |
+
+        **How the 24-hour window works:**
+
+        - The window is fixed at **24 hours from message creation** (`created_at`) and cannot be configured per message.
+        - It mirrors the ephemeral *attachments* 1-day backstop, so a message and any media it carries expire together.
+        - Expiry is delivery-independent — the clock starts when the message is created, not when it is delivered or read.
+
+        **What you observe:**
+
+        - **No expiry timestamp is exposed.** API responses and webhook payloads do not include the deletion time. If you need it, compute `created_at + 24h` yourself.
+        - **No deletion webhook is sent.** There is no `message.deleted` event — a message simply stops being retrievable once its window passes.
+        - **Delivery is unaffected.** Ephemeral messages send, deliver, and fire the usual `message.sent` / `message.received` and status webhooks exactly like standard messages. Only retention changes.
+
+        **When to choose ephemeral:**
+
+        - You have a compliance requirement that the platform must not retain message content beyond a short window.
+        - The conversation is high-sensitivity (PHI, financial, identity verification) and you do not want it sitting in storage long-term.
+        - Your application is the system of record — you capture what you need from the delivery webhook in real time and do not rely on reading message history back from Linq later.
+
+        **Important:** ephemeral applies in *both directions* — messages you send **and** messages received by the phone numbers in that scope. Because Linq can no longer return the message after 24 hours, persist anything you need to keep from the webhook payload at the time it is delivered.
         """
         from .resources.messages import AsyncMessagesResourceWithStreamingResponse
 
@@ -3365,7 +3681,7 @@ class AsyncLinqAPIV3WithStreamedResponse:
         |---|---|---|
         | Attachment bytes | Retained until you `DELETE` | **Auto-removed after 1 day**, also removable via `DELETE` |
         | Attachment metadata (id, filename, mime type, size) | Retained until you `DELETE` | Removed alongside the bytes |
-        | Message body & parts | Retained per message-retention policy | Retained per message-retention policy |
+        | Message body & parts | Retained per message-retention policy | Retained per message-retention policy — unless the line also has **ephemeral messages** enabled (see the Messages page), in which case the message and its parts are deleted 24 hours after creation |
         | Audit log of deletions | Retained per platform retention policy | Retained per platform retention policy |
 
         **In transit:** TLS 1.2+ everywhere. **At rest:** AES-256 (server-side encryption).
@@ -3413,6 +3729,20 @@ class AsyncLinqAPIV3WithStreamedResponse:
 
         return AsyncPhoneNumbersResourceWithStreamingResponse(self._client.phone_numbers)
 
+    @cached_property
+    def available_number(self) -> available_number.AsyncAvailableNumberResourceWithStreamingResponse:
+        """Phone Numbers represent the phone numbers assigned to your partner account.
+
+        Use the list phone numbers endpoint to discover which phone numbers are available
+        for sending messages.
+
+        When creating chats, listing chats, or sending a voice memo, use one of your assigned phone numbers
+        in the `from` field.
+        """
+        from .resources.available_number import AsyncAvailableNumberResourceWithStreamingResponse
+
+        return AsyncAvailableNumberResourceWithStreamingResponse(self._client.available_number)
+
     @cached_property
     def webhook_events(self) -> webhook_events.AsyncWebhookEventsResourceWithStreamingResponse:
         """

{linq_python-0.15.0 → linq_python-0.15.1}/src/linq/_version.py

@@ -1,4 +1,4 @@
 # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details.
 
 __title__ = "linq"
-__version__ = "0.15.0"  # x-release-please-version
+__version__ = "0.15.1"  # x-release-please-version

{linq_python-0.15.0 → linq_python-0.15.1}/src/linq/resources/__init__.py

@@ -65,6 +65,14 @@ from .webhook_events import (
     WebhookEventsResourceWithStreamingResponse,
     AsyncWebhookEventsResourceWithStreamingResponse,
 )
+from .available_number import (
+    AvailableNumberResource,
+    AsyncAvailableNumberResource,
+    AvailableNumberResourceWithRawResponse,
+    AsyncAvailableNumberResourceWithRawResponse,
+    AvailableNumberResourceWithStreamingResponse,
+    AsyncAvailableNumberResourceWithStreamingResponse,
+)
 from .webhook_subscriptions import (
     WebhookSubscriptionsResource,
     AsyncWebhookSubscriptionsResource,
@@ -105,6 +113,12 @@ __all__ = [
     "AsyncPhoneNumbersResourceWithRawResponse",
     "PhoneNumbersResourceWithStreamingResponse",
     "AsyncPhoneNumbersResourceWithStreamingResponse",
+    "AvailableNumberResource",
+    "AsyncAvailableNumberResource",
+    "AvailableNumberResourceWithRawResponse",
+    "AsyncAvailableNumberResourceWithRawResponse",
+    "AvailableNumberResourceWithStreamingResponse",
+    "AsyncAvailableNumberResourceWithStreamingResponse",
     "WebhookEventsResource",
     "AsyncWebhookEventsResource",
     "WebhookEventsResourceWithRawResponse",