@curviate/sdk 0.16.0 → 0.18.0

package/dist/index.d.ts

@@ -428,6 +428,26 @@ interface paths {
         patch?: never;
         trace?: never;
     };
+    "/v1/{account_id}/companies/{identifier}/follow-invite": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Invite connections to follow a page
+         * @description Invites one or more of the connected account's 1st-degree connections to follow a company page it administers with the invite-to-follow entitlement. Pass the AC… member ids from an invitable-followers read. Returns one outcome per invitee, in request order, for an all-valid request. If any invitee id is invalid, the whole request is rejected (404), with no partial success. Re-inviting an already-invited member is a safe no-op (the same invitation id, never a duplicate). Only identifiers transit. Nothing is stored.
+         */
+        post: operations["postV1AccountIdCompaniesIdentifierFollowInvite"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/v1/{account_id}/companies/{identifier}/followers": {
         parameters: {
             query?: never;
@@ -497,7 +517,7 @@ interface paths {
         };
         /**
          * Retrieve one admin conversation
-         * @description Returns a single conversation from a company page's admin inbox by id — the same shape as a list item. The connected account must administer the page. Beta — deep pagination is being validated at scale. Single-page listing and termination are verified; deep pagination (many pages / large cursor round-trips) is provisional until validated against a busier inbox.
+         * @description Returns a single conversation from a company page's admin inbox by id — the same shape as a list item. The connected account must administer the page.
          */
         get: operations["getV1AccountIdCompaniesIdentifierChatsChatId"];
         put?: never;
@@ -517,11 +537,15 @@ interface paths {
         };
         /**
          * List a conversation's messages
-         * @description Returns a page of one conversation's messages, newest-first. Message text passes through and is never stored. An unknown conversation returns 404 (the empty page is not trusted at face value); a genuinely empty existing thread returns an empty list. The connected account must administer the page. Beta — deep pagination is being validated at scale. Single-page listing and termination are verified; deep pagination (many pages / large cursor round-trips) is provisional until validated against a busier inbox.
+         * @description Returns a page of one conversation's messages, newest-first. Message text passes through and is never stored. An unknown conversation returns 404 (the empty page is not trusted at face value); a genuinely empty existing thread returns an empty list. The connected account must administer the page.
          */
         get: operations["getV1AccountIdCompaniesIdentifierChatsChatIdMessages"];
         put?: never;
-        post?: never;
+        /**
+         * Reply as the company page
+         * @description Sends a message into an existing company-inbox conversation, as the page. chat_id must be the send-ready COMPANY_ form from GET /v1/{account_id}/inboxes/{inbox_id}/chats (the 2-… id from this group's chat reads is not send-ready and returns a guiding 400). The connected account must administer the page. Reply-only: a page can never start a new conversation, only answer an existing one. Send application/json with text, base64 attachments (max 5 MiB per file), or both; at least one of text or attachments is required. Message content passes through to the platform and is never stored. The response's sent_as field names the acting identity that was actually used.
+         */
+        post: operations["postV1AccountIdCompaniesIdentifierChatsChatIdMessages"];
         delete?: never;
         options?: never;
         head?: never;
@@ -537,7 +561,7 @@ interface paths {
         };
         /**
          * Retrieve one message from a conversation
-         * @description Returns a single message from a company page's admin inbox, scoped to its conversation — the same shape as a messages-list item. Both chat_id and message_id are required. The connected account must administer the page. Beta — deep pagination is being validated at scale. Single-page listing and termination are verified; deep pagination (many pages / large cursor round-trips) is provisional until validated against a busier inbox.
+         * @description Returns a single message from a company page's admin inbox, scoped to its conversation — the same shape as a messages-list item. Both chat_id and message_id are required. The connected account must administer the page.
          */
         get: operations["getV1AccountIdCompaniesIdentifierChatsChatIdMessagesMessageId"];
         put?: never;
@@ -871,7 +895,7 @@ interface paths {
         put?: never;
         /**
          * Send a message
-         * @description Sends a message into an existing chat. Send application/json with text, base64 attachments (max 5 MiB per file), or both; at least one of text or attachments is required. Message content passes through to the platform and is never stored.
+         * @description Sends a message into an existing chat. Send application/json with text, base64 attachments (max 5 MiB per file), or both; at least one of text or attachments is required. Message content passes through to the platform and is never stored. Sending on behalf of a company page: use a COMPANY_ chat id (from GET /v1/{account_id}/inboxes/{inbox_id}/chats) and the message sends AS THE PAGE, no separate parameter needed. The response's sent_as field names the acting identity that was actually used. Company pages are reply-only: this endpoint can answer an existing conversation on a page's behalf, but a page can never start a new one.
          */
         post: operations["postV1AccountIdChatsChatIdMessages"];
         delete?: never;
@@ -1017,7 +1041,7 @@ interface paths {
         };
         /**
          * List an inbox's conversations
-         * @description Returns a paginated list of an inbox's conversations, newest-activity-first. Each chat's id is send-ready: pass it directly to the send-message endpoint to reply — a company inbox's chat id (e.g. 'COMPANY_83734124_2-…') replies AS THE PAGE, no separate parameter needed. Works identically for personal (CLASSIC_) inboxes. Company pages are reply-only (reply_only:true on the inbox, from GET /inboxes) — they cannot start a new conversation. Unknown inbox id returns 404.
+         * @description Returns a paginated list of an inbox's conversations, newest-activity-first. Each chat's id is send-ready: pass it directly to the send-message endpoint to reply — a company inbox's chat id (e.g. 'COMPANY_83734124_2-…') replies AS THE PAGE, no separate parameter needed. Works identically for personal (CLASSIC_) inboxes. Company pages are reply-only (reply_only:true on the inbox, from GET /inboxes) — they cannot start a new conversation. A malformed inbox_id returns 400 INVALID_REQUEST; a well-formed id for a mailbox this account does not administer returns 403 RESOURCE_ACCESS_RESTRICTED (no existence disclosure) — there is no 404 for this endpoint.
          */
         get: operations["getV1AccountIdInboxesInboxIdChats"];
         put?: never;
@@ -5474,6 +5498,163 @@ interface operations {
             };
         };
     };
+    postV1AccountIdCompaniesIdentifierFollowInvite: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description The connected LinkedIn account, which must administer the page with invite rights. */
+                account_id: string;
+                /** @description The company's numeric id (e.g. 112013061) — the id field of GET /v1/{account_id}/companies/{identifier} or a POST /v1/{account_id}/search/companies result. A public handle or URN is not accepted here — pass the numeric id. */
+                identifier: string;
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": {
+                    /** @description The AC… member ids to invite to follow the page. Each is the id field of an invitable-followers read. Required, 1 to 50 per request. */
+                    invitee_ids: string[];
+                };
+            };
+        };
+        responses: {
+            /** @description One per-invitee outcome for each requested member, in request order, for an all-valid request. If any invitee id is invalid, the whole request is rejected (404), with no partial success. Re-inviting an already-invited member returns the same invitation id with status "already_invited", an idempotent no-op, never a duplicate. Only identifiers transit; nothing is stored. */
+            200: {
+                headers: {
+                    "RateLimit-Policy": components["headers"]["RateLimit-Policy"];
+                    RateLimit: components["headers"]["RateLimit"];
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        /**
+                         * @description Response type discriminator.
+                         * @enum {string}
+                         */
+                        object: "company_follow_invite_result";
+                        /** @description One entry per requested invitee, in request order, for an all-valid request. If any invitee id is invalid, the whole request is rejected (404), with no partial success. */
+                        results: {
+                            /**
+                             * @description Item type discriminator.
+                             * @enum {string}
+                             */
+                            object: "company_follow_invite";
+                            /** @description The member id from the request, echoed back. */
+                            invitee_id: string;
+                            /**
+                             * @description Per-invitee outcome. "invited": a new follow-invitation was created. "already_invited": a pending invitation already existed (idempotent no-op; the same invitation_id is returned, never a duplicate). "ineligible": the member is not an invitable 1st-degree connection. "not_found": the member id did not resolve.
+                             * @enum {string}
+                             */
+                            status: "invited" | "already_invited" | "ineligible" | "not_found";
+                            /** @description The invitation id, present for "invited" and "already_invited", null for a per-invitee failure. */
+                            invitation_id: string | null;
+                            /** @description Present only for a per-invitee failure ("ineligible" / "not_found"); null otherwise. */
+                            error: {
+                                /** @description Canonical error code for this invitee's failure. */
+                                code?: string;
+                                /** @description Human-readable failure reason. */
+                                message?: string;
+                            } | null;
+                        }[];
+                    };
+                };
+            };
+            /** @description Empty, over-cap (>50), or malformed invitee_ids, or a non-numeric identifier, rejected before any send. */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+            /** @description Missing or invalid API key. */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+            /** @description The account does not administer this page with the invite-to-follow entitlement (fail-closed), or lacks the required Core seat. */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+            /** @description The account_id does not belong to this tenant, or a wholly-invalid invitee did not resolve. */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+            /** @description The account is restricted and cannot perform this operation. */
+            422: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+            /** @description The follow-invite credit or rate budget is exhausted. Slow down and retry after the hinted delay. */
+            429: {
+                headers: {
+                    "RateLimit-Policy": components["headers"]["RateLimit-Policy"];
+                    RateLimit: components["headers"]["RateLimit"];
+                    "Retry-After": components["headers"]["Retry-After"];
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+            /** @description Internal error. */
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+            /** @description A temporary error occurred. Please try again. */
+            502: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+            /** @description Service unavailable. */
+            503: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+            /** @description Gateway timeout. */
+            504: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
     getV1AccountIdCompaniesIdentifierFollowers: {
         parameters: {
             query?: {
@@ -6274,6 +6455,184 @@ interface operations {
             };
         };
     };
+    postV1AccountIdCompaniesIdentifierChatsChatIdMessages: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description The connected LinkedIn account, which must administer the page. */
+                account_id: string;
+                /** @description The company's numeric id (e.g. 112013061) — the id field of GET /v1/{account_id}/companies/{identifier} or a POST /v1/{account_id}/search/companies result. A public handle or URN is not accepted here — pass the numeric id. */
+                identifier: string;
+                /** @description The COMPANY_ chat id to reply to (e.g. 'COMPANY_83734124_2-…'), from GET /v1/{account_id}/inboxes/{inbox_id}/chats, not the 2-… id from this group's chat reads (that form is rejected with a guiding 400). */
+                chat_id: string;
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": {
+                    /** @description Message text (1–8000 chars). Optional when at least one attachment is supplied. */
+                    text?: string;
+                    /** @description Optional message ID to quote or reply to. */
+                    quote_id?: string;
+                    /** @description Optional file attachments (base64-encoded). */
+                    attachments?: {
+                        /** @description Base64-encoded file bytes. */
+                        content: string;
+                        /** @description Attachment MIME type (e.g. image/png, application/pdf). */
+                        content_type: string;
+                        /** @description File name for the attachment. */
+                        filename: string;
+                    }[];
+                };
+            };
+        };
+        responses: {
+            /** @description Message sent as the page. Returns the new message_id and sent_as, the acting identity, always kind:'company' on this endpoint. company_id is null when the page could not be correlated to a managed page on Curviate, even though the page itself and its name are still known. */
+            201: {
+                headers: {
+                    "RateLimit-Policy": components["headers"]["RateLimit-Policy"];
+                    RateLimit: components["headers"]["RateLimit"];
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": {
+                        /**
+                         * @description Response type discriminator.
+                         * @enum {string}
+                         */
+                        object?: "message_sent";
+                        /** @description The sent message's identifier. */
+                        message_id?: string;
+                        /** @description The identity this message was actually sent as. */
+                        sent_as?: {
+                            /**
+                             * @description Which identity sent the message.
+                             * @enum {string}
+                             */
+                            kind?: "personal" | "company";
+                            /** @description Company inboxes only. Null when this page is not one of the account's managed companies on Curviate, even though the page itself, and its name, are still known. */
+                            company_id?: string | null;
+                            /** @description Company inboxes only. The page's display name, or null in the rare case the page itself could not be resolved at all. */
+                            name?: string | null;
+                        };
+                    };
+                };
+            };
+            /** @description Empty body or neither text nor attachment supplied, a non-numeric identifier, or chat_id is not the send-ready COMPANY_ form (the guiding error names the required form and its /inboxes source). */
+            400: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+            /** @description Missing or invalid API key. */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+            /** @description The account does not administer this page (the substrate's own admin gate), the COMPANY_ chat's mailbox correlates to a DIFFERENT company than {identifier}, or the account lacks the required Core seat. */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+            /** @description The account_id does not belong to this tenant. */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+            /** @description Payload too large, an attachment exceeds 5 MiB or the total body exceeds 8 MiB. */
+            413: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+            /** @description Unsupported media type, the request must use application/json. */
+            415: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+            /** @description The account is restricted and cannot be queried. */
+            422: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+            /** @description Rate limited, slow down and retry after the hinted delay. */
+            429: {
+                headers: {
+                    "RateLimit-Policy": components["headers"]["RateLimit-Policy"];
+                    RateLimit: components["headers"]["RateLimit"];
+                    "Retry-After": components["headers"]["Retry-After"];
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+            /** @description Internal error. */
+            500: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+            /** @description A temporary error occurred. Please try again. */
+            502: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+            /** @description Service unavailable. */
+            503: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+            /** @description Gateway timeout. */
+            504: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
     getV1AccountIdCompaniesIdentifierChatsChatIdMessagesMessageId: {
         parameters: {
             query?: never;
@@ -9700,7 +10059,7 @@ interface operations {
             path: {
                 /** @description The account ID (`acc_…`) that owns the chat. */
                 account_id: string;
-                /** @description The unique identifier of the chat to send the message to. */
+                /** @description The unique identifier of the chat to send the message to. A COMPANY_ chat id (e.g. 'COMPANY_83734124_2-YTQ3ODU3Njgt', from the inboxes endpoints) sends this message as that company page instead of the connected member. */
                 chat_id: string;
             };
             cookie?: never;
@@ -9725,7 +10084,7 @@ interface operations {
             };
         };
         responses: {
-            /** @description Message sent. Returns the new message_id and sent_as — the acting identity. A COMPANY_ chat id (e.g. `COMPANY_83734124_2-…`) sends AS THE PAGE and echoes sent_as:{kind:'company',company_id,name} (company_id may be null when the page could not be correlated to a managed page); any other chat id sends as the connected member and echoes sent_as:{kind:'personal'}. Never infer the acting identity from the message's sender field. */
+            /** @description Message sent. Returns the new message_id and sent_as, the acting identity. Reply as a company page simply by sending into one of its chat ids (from GET /v1/{account_id}/inboxes/{inbox_id}/chats): a COMPANY_ chat id (e.g. `COMPANY_83734124_2-…`) sends AS THE PAGE and echoes sent_as:{kind:'company',company_id,name} (company_id is null when the page could not be correlated to a managed page). Any other chat id sends as the connected member and echoes sent_as:{kind:'personal'}. Never infer the acting identity from the message's sender field, only from sent_as. */
             201: {
                 headers: {
                     "RateLimit-Policy": components["headers"]["RateLimit-Policy"];
@@ -9748,10 +10107,10 @@ interface operations {
                              * @enum {string}
                              */
                             kind?: "personal" | "company";
-                            /** @description Company inboxes only — null when uncorrelatable. */
+                            /** @description Company inboxes only. Null when this page is not one of the account's managed companies on Curviate, even though the page itself, and its name, are still known. */
                             company_id?: string | null;
-                            /** @description Company inboxes only — the page's display name. */
-                            name?: string;
+                            /** @description Company inboxes only. The page's display name, or null in the rare case the page itself could not be resolved at all. */
+                            name?: string | null;
                         };
                     };
                 };
@@ -10806,7 +11165,7 @@ interface operations {
         };
         requestBody?: never;
         responses: {
-            /** @description The account's inboxes — personal plus, when the company product is attached, one entry per company page × folder (e.g. id='COMPANY_83734124_PRIMARY'). When no company inbox exists, hint names the Company Pages reconnect requirement instead of returning silently empty. */
+            /** @description The account's inboxes: its own personal inbox, plus, when the company product is attached, one entry per company page (e.g. id='COMPANY_83734124_PRIMARY'). When no company inbox exists, hint names the Company Pages reconnect requirement instead of returning silently empty. This is the discovery step of the reply-as-a-page flow: find a company inbox here, read its conversations with GET /v1/{account_id}/inboxes/{inbox_id}/chats, then reply with the existing POST /v1/{account_id}/chats/{chat_id}/messages using one of its chat ids. */
             200: {
                 headers: {
                     "RateLimit-Policy": components["headers"]["RateLimit-Policy"];
@@ -10826,7 +11185,7 @@ interface operations {
                              * @enum {string}
                              */
                             object?: "inbox";
-                            /** @description Inbox identifier — pass to the inbox-chats endpoint. */
+                            /** @description Inbox identifier. Pass it to the inbox-chats endpoint below to read its conversations. */
                             id?: string;
                             /**
                              * @description Whether this is the account's own inbox or a company page's.
@@ -10837,14 +11196,14 @@ interface operations {
                             folder?: string;
                             /** @description Personal: the folder's display name. Company: the page's display name. */
                             name?: string | null;
-                            /** @description Company inboxes only — the managed-company id this mailbox was correlated to, or null when it could not be correlated (never a fabricated id). */
+                            /** @description Company inboxes only. The managed-company id this mailbox was correlated to, or null when it could not be correlated (never a fabricated id). */
                             company_id?: string | null;
-                            /** @description Company inboxes only — the substrate's internal mailbox id (distinct from company_id). */
+                            /** @description Company inboxes only. The substrate's internal mailbox id (distinct from company_id). */
                             mailbox_id?: string | null;
-                            /** @description true for company inboxes — company pages can only reply to existing conversations, never start one. */
+                            /** @description True for company inboxes: a company page can only reply to an existing conversation, it can never start one. */
                             reply_only?: boolean;
                         }[];
-                        /** @description Present only when no company inbox exists — names the reconnect requirement. */
+                        /** @description Present only when no company inbox exists. Names the reconnect requirement. */
                         hint?: string;
                     };
                 };
@@ -10936,7 +11295,7 @@ interface operations {
         };
         requestBody?: never;
         responses: {
-            /** @description A page of the inbox's conversations, newest-activity-first. Each chat's id is send-ready — pass it directly to POST .../chats/{chat_id}/messages to reply (a company inbox's chats carry ids like 'COMPANY_83734124_2-YTQ3ODU3Njgt'; replying with that id sends AS THE PAGE, no separate parameter needed). Works identically for personal (CLASSIC_) inboxes. */
+            /** @description A page of the inbox's conversations, newest-activity-first, in the same shape as GET /v1/{account_id}/chats. Each chat's id is send-ready: pass it directly to POST /v1/{account_id}/chats/{chat_id}/messages to reply. A company inbox's chats carry ids like 'COMPANY_83734124_2-YTQ3ODU3Njgt'; replying with that id sends AS THE PAGE, no separate parameter needed, and the send response's sent_as field confirms it. Works identically for personal (CLASSIC_) inboxes. */
             200: {
                 headers: {
                     "RateLimit-Policy": components["headers"]["RateLimit-Policy"];
@@ -10950,13 +11309,112 @@ interface operations {
                          * @enum {string}
                          */
                         object?: "inbox_chat_list";
-                        items?: Record<string, never>[];
-                        /** @description Next-page cursor; follow until items is empty. */
+                        items?: {
+                            /**
+                             * @description Response type discriminator.
+                             * @enum {string}
+                             */
+                            object?: "chat";
+                            /** @description Chat identifier. */
+                            id?: string;
+                            /** @description Account id that owns this chat. */
+                            account_id?: string;
+                            /** @description Chat display name, or null. */
+                            name?: string | null;
+                            /**
+                             * @description Conversation type.
+                             * @enum {string}
+                             */
+                            type?: "1to1" | "group" | "channel";
+                            is_group?: boolean;
+                            is_1to1?: boolean;
+                            is_channel?: boolean;
+                            is_pinned?: boolean;
+                            is_readonly?: boolean;
+                            /** @description True if the chat is archived. */
+                            is_archived?: boolean;
+                            /** @description True if notifications for this chat are muted. */
+                            muted_until?: boolean;
+                            /** @description Number of unread messages in this chat. */
+                            unread_count?: number;
+                            /** @description Folder labels assigned to this chat. */
+                            folders?: string[];
+                            /** @description The platform this chat originates from. */
+                            provider?: string;
+                            /** @description ISO-8601 UTC creation timestamp. */
+                            created_at?: string;
+                            /** @description ISO-8601 UTC timestamp of the last message. */
+                            last_message_timestamp?: string;
+                            /** @description Identifier of the 1:1 counterpart. */
+                            user_id?: string;
+                            /** @description The most recent message in the chat. */
+                            last_message?: {
+                                /**
+                                 * @description Response type discriminator.
+                                 * @enum {string}
+                                 */
+                                object?: "message";
+                                /** @description Message identifier. */
+                                id?: string;
+                                /** @description Account id that owns this message. */
+                                account_id?: string;
+                                /** @description Chat this message belongs to. */
+                                chat_id?: string;
+                                /** @description Identifier of the sender. */
+                                sender_id?: string;
+                                /** @description Full message text (content pass-through — never stored). */
+                                text?: string | null;
+                                /** @description Attachment descriptors (no bytes — use the attachment endpoint to download). */
+                                attachments?: {
+                                    /** @description Attachment identifier. */
+                                    id?: string;
+                                    /** @description MIME type of the attachment. */
+                                    mimetype?: string;
+                                    /** @description Attachment kind: file | img | video | audio. */
+                                    type?: string;
+                                    /** @description Original file name. */
+                                    filename?: string;
+                                    /** @description Size in bytes. */
+                                    file_size?: number;
+                                    /** @description True when the attachment is no longer available. */
+                                    unavailable?: boolean | null;
+                                }[];
+                                /** @description ISO-8601 UTC send timestamp. */
+                                timestamp?: string;
+                                /** @description True if the connected account sent this message. */
+                                is_sender?: boolean;
+                                is_seen?: boolean;
+                                is_delivered?: boolean;
+                                is_edited?: boolean;
+                                /** @description True if the account is mentioned in this message. */
+                                is_mentionned?: boolean;
+                                /** @description Per-type reaction breakdown on the message. */
+                                reactions?: {
+                                    type?: string;
+                                    count?: number;
+                                }[];
+                                /** @description Total reaction count across all types (derived). */
+                                reaction_count?: number;
+                                /** @description The platform this message originates from. */
+                                provider?: string;
+                            };
+                            /** @description The 1:1 counterpart's profile. */
+                            user?: {
+                                /** @description Identifier of the counterpart. */
+                                id?: string;
+                                /** @description individual | organization. */
+                                type?: string;
+                                display_name?: string;
+                                profile_url?: string;
+                                public_picture_url?: string;
+                            };
+                        }[];
+                        /** @description Next-page cursor. Follow until items is empty. */
                         cursor?: string | null;
                     };
                 };
             };
-            /** @description limit out of range (1–25) or malformed cursor. */
+            /** @description limit out of range (1-25), malformed cursor, or a malformed/unknown-folder inbox_id (rejected before the substrate is ever called; see GET /inboxes for valid ids). */
             400: {
                 headers: {
                     [name: string]: unknown;
@@ -10974,7 +11432,7 @@ interface operations {
                     "application/json": components["schemas"]["Error"];
                 };
             };
-            /** @description The connected account is not an admin of this page. */
+            /** @description The connected account does not administer this inbox: either it is not an admin of this page, or the mailbox is unknown to this account. No existence disclosure. */
             403: {
                 headers: {
                     [name: string]: unknown;
@@ -10983,15 +11441,6 @@ interface operations {
                     "application/json": components["schemas"]["Error"];
                 };
             };
-            /** @description The inbox does not exist for this account. */
-            404: {
-                headers: {
-                    [name: string]: unknown;
-                };
-                content: {
-                    "application/json": components["schemas"]["Error"];
-                };
-            };
             /** @description Rate limited. */
             429: {
                 headers: {
@@ -28232,7 +28681,7 @@ declare class JobsResource {
 }
 
 /**
- * Companies resource — 12 methods.
+ * Companies resource — 14 methods.
  *
  * Account-scoped: the bound context injects `account_id` as the leading
  * `/v1/` path segment on every request (account-first grammar) — the 0.14.1
@@ -28246,10 +28695,11 @@ declare class JobsResource {
  * `followers()` — re-added under a different item shape (`company_follower`,
  * carrying `degree`/`followed_at`) than the pre-0.15.0 method of the same
  * name. `invitableFollowers()` lists connections the account can invite to
- * follow the page. All three require the account to administer the target
- * page (`managed()` for the caller's own set; `followers`/`invitableFollowers`
- * take the target company's numeric provider_id, same as `employees`/`posts`/
- * `jobs`).
+ * follow the page; `followInvite()` sends the invitation —
+ * pass the `AC…` member ids `invitableFollowers()` returned. All four require
+ * the account to administer the target page (`managed()` for the caller's
+ * own set; `followers`/`invitableFollowers`/`followInvite` take the target
+ * company's numeric provider_id, same as `employees`/`posts`/`jobs`).
  *
  * `chats()` / `chat()` / `messages()` / `message()` / `searchChats()` are the
  * company page's admin message inbox — a distinct conversation surface from
@@ -28257,6 +28707,11 @@ declare class JobsResource {
  * **Beta:** single-page listing and termination are verified; deep pagination
  * (many pages / large cursor round-trips) is still being validated against a
  * busier inbox.
+ *
+ * `sendMessage()` is the inbox's one write: reply to an existing
+ * conversation AS THE PAGE. It requires the send-ready `COMPANY_` chat id
+ * from `inboxes.listChats()`, not the `2-…` id the reads above return.
+ * Reply-only, same admin requirement as the reads.
  */
 
 type CompanyProfile = paths["/v1/{account_id}/companies/{identifier}"]["get"]["responses"]["200"]["content"]["application/json"];
@@ -28272,6 +28727,8 @@ type CompanyFollowerListPage = paths["/v1/{account_id}/companies/{identifier}/fo
 type CompanyFollowerListQuery = NonNullable<paths["/v1/{account_id}/companies/{identifier}/followers"]["get"]["parameters"]["query"]>;
 type CompanyInvitableFollowerListPage = paths["/v1/{account_id}/companies/{identifier}/invitable-followers"]["get"]["responses"]["200"]["content"]["application/json"];
 type CompanyInvitableFollowerListQuery = NonNullable<paths["/v1/{account_id}/companies/{identifier}/invitable-followers"]["get"]["parameters"]["query"]>;
+type CompanyFollowInviteBody = paths["/v1/{account_id}/companies/{identifier}/follow-invite"]["post"]["requestBody"]["content"]["application/json"];
+type CompanyFollowInviteResult = paths["/v1/{account_id}/companies/{identifier}/follow-invite"]["post"]["responses"]["200"]["content"]["application/json"];
 type CompanyChatListPage = paths["/v1/{account_id}/companies/{identifier}/chats"]["get"]["responses"]["200"]["content"]["application/json"];
 type CompanyChatListQuery = NonNullable<paths["/v1/{account_id}/companies/{identifier}/chats"]["get"]["parameters"]["query"]>;
 type CompanyChat = paths["/v1/{account_id}/companies/{identifier}/chats/{chat_id}"]["get"]["responses"]["200"]["content"]["application/json"];
@@ -28280,6 +28737,8 @@ type CompanyChatMessageListQuery = NonNullable<paths["/v1/{account_id}/companies
 type CompanyChatMessage = paths["/v1/{account_id}/companies/{identifier}/chats/{chat_id}/messages/{message_id}"]["get"]["responses"]["200"]["content"]["application/json"];
 type CompanyChatSearchPage = paths["/v1/{account_id}/companies/{identifier}/chats/search"]["get"]["responses"]["200"]["content"]["application/json"];
 type CompanyChatSearchQuery = NonNullable<paths["/v1/{account_id}/companies/{identifier}/chats/search"]["get"]["parameters"]["query"]>;
+type CompanySendMessageBody = paths["/v1/{account_id}/companies/{identifier}/chats/{chat_id}/messages"]["post"]["requestBody"]["content"]["application/json"];
+type CompanySendMessageResult = paths["/v1/{account_id}/companies/{identifier}/chats/{chat_id}/messages"]["post"]["responses"]["201"]["content"]["application/json"];
 declare class CompaniesResource {
     protected readonly ctx: RequestContext;
     constructor(ctx: RequestContext);
@@ -28345,6 +28804,20 @@ declare class CompaniesResource {
      * currently invitable.
      */
     invitableFollowers(identifier: string, params?: CompanyInvitableFollowerListQuery): Promise<CompanyInvitableFollowerListPage>;
+    /**
+     * Invite the connected account's 1st-degree connections to follow the
+     * company page. `POST /v1/{account_id}/companies/{identifier}/follow-invite`
+     *
+     * The account must administer the page with the invite-to-follow
+     * entitlement (see `managed()`). `identifier` must be the company's numeric
+     * provider_id. Pass the `AC…` member ids from an `invitableFollowers()`
+     * read. All-or-nothing: for an all-valid request, resolves to one outcome
+     * per requested invitee, in request order. If any invitee id is invalid,
+     * the whole request rejects with a 404, not a partial result.
+     * Re-inviting an already-invited member is a safe no-op, the same
+     * invitation id, never a duplicate.
+     */
+    followInvite(identifier: string, body: CompanyFollowInviteBody): Promise<CompanyFollowInviteResult>;
     /**
      * List the conversations in a company page's admin message inbox,
      * newest-activity-first.
@@ -28389,6 +28862,42 @@ declare class CompaniesResource {
      * administer the page. Beta — see `chats()`.
      */
     searchChats(identifier: string, params?: CompanyChatSearchQuery): Promise<CompanyChatSearchPage>;
+    /**
+     * Reply to a company-inbox conversation, AS THE PAGE.
+     * `POST /v1/{account_id}/companies/{identifier}/chats/{chat_id}/messages`
+     *
+     * `chatId` must be the send-ready `COMPANY_` chat id, not the `2-…` id
+     * `chats()`/`chat()`/`searchChats()` return. Get the `COMPANY_` id from
+     * `inboxes.listChats()` (`GET /v1/{account_id}/inboxes/{inbox_id}/chats`).
+     * A `2-…` or personal chat id is rejected with a guiding 400 that names
+     * the required form and its source.
+     *
+     * Reply-only: this method can only answer an existing conversation, it
+     * cannot start a new one on the page's behalf. The connected account
+     * must administer the page (`managed()`). `attachments[]`, when
+     * supplied, carry base64-encoded file bytes, always sent as JSON, never
+     * multipart. At least one of `text`/`attachments` is required (enforced
+     * server-side). Message content passes through verbatim and is never
+     * stored.
+     *
+     * The response echoes `sent_as`, the acting identity actually used:
+     * `{ kind: "company", company_id, name }` (`company_id` is `null` when
+     * the page could not be correlated to a managed page on Curviate).
+     *
+     * @example
+     * const acc = curviate.account("acc_YOUR_ACCOUNT_ID");
+     * const { items: inboxes } = await acc.inboxes.list({ kind: "company" });
+     * const pageInbox = inboxes[0]!; // e.g. id "COMPANY_83734124_PRIMARY"
+     *
+     * const { items: chats } = await acc.inboxes.listChats(pageInbox.id);
+     * const chatId = chats[0]!.id as string; // e.g. "COMPANY_83734124_2-YTQ3ODU3Njgt"
+     *
+     * const result = await acc.companies.sendMessage("112013061", chatId, {
+     *   text: "Thanks for reaching out, happy to help!",
+     * });
+     * console.log(result.sent_as); // { kind: "company", company_id: "112013061", name: "RedHire" }
+     */
+    sendMessage(identifier: string, chatId: string, body: CompanySendMessageBody): Promise<CompanySendMessageResult>;
 }
 
 /**