@curviate/sdk 0.40.1 → 0.42.0

package/dist/index.d.ts

@@ -90,6 +90,15 @@ interface RequestArgs {
      */
     query?: Record<string, string | number | boolean | string[] | undefined | null>;
     body?: unknown;
+    /**
+     * A raw (non-JSON) request body with its own `Content-Type`, for the one
+     * route that takes a file as the body (`drafts.uploadAttachment`). Mutually
+     * exclusive with `body`.
+     */
+    rawBody?: {
+        data: Blob | ArrayBuffer | Uint8Array;
+        contentType: string;
+    };
 }
 /** The bound caller a resource receives. */
 type RequestFn = <T = unknown>(args: RequestArgs) => Promise<T>;
@@ -723,7 +732,7 @@ interface paths {
         put?: never;
         /**
          * Search posts
-         * @description Searches LinkedIn posts using structured filters. To search from a pasted LinkedIn search URL instead, use POST .../search. Post text, engagement counters, author, and attachments are returned.
+         * @description Searches LinkedIn posts using structured filters. To search from a pasted LinkedIn search URL instead, use POST .../search. Returns text, counts, author and attachments; the text can repeat fragments around links, mentions and hashtags, so get the post by its id for the clean body.
          */
         post: operations["postV1AccountIdSearchPosts"];
         delete?: never;
@@ -1575,7 +1584,7 @@ interface paths {
         put?: never;
         /**
          * Create a post
-         * @description Publishes a post on the authenticated LinkedIn account. Send application/json; attach files as base64 objects. Post text passes through to the platform and is never stored.
+         * @description Publishes a post now; JSON, files as base64. Text is never stored. A publish record (account, post id, time) is kept, listed by GET /v1/drafts?status=published and removed when the post is deleted. To publish later, create a Draft at POST /v1/drafts.
          */
         post: operations["postV1AccountIdPosts"];
         delete?: never;
@@ -1696,6 +1705,98 @@ interface paths {
         patch?: never;
         trace?: never;
     };
+    "/v1/drafts": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * List drafts
+         * @description Lists your Drafts and, with status=published, publish records (account, post id, time; never Drafts). Filter by status, account (or none) and a [from, to) range on each item's own date.
+         */
+        get: operations["getV1Drafts"];
+        put?: never;
+        /**
+         * Create a draft
+         * @description Stores an unpublished post until it is published or deleted. Every field is optional, the account too; a Draft has at most one account and can move between yours. Up to 50 Drafts and 2 GiB of media per account, and per no-account. A retry creates a second Draft.
+         */
+        post: operations["postV1Drafts"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/drafts/{id}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        /**
+         * Retrieve a draft
+         * @description Returns one Draft, with a fresh signed link (valid 1 hour) for each attachment.
+         */
+        get: operations["getV1DraftsId"];
+        put?: never;
+        post?: never;
+        /**
+         * Delete a draft
+         * @description Deletes the Draft and its stored media.
+         */
+        delete: operations["deleteV1DraftsId"];
+        options?: never;
+        head?: never;
+        /**
+         * Update a draft
+         * @description Partial update: an omitted field is left as is, null clears it. attachments replaces the whole list ({id} keeps an existing file, a base64 object adds one, anything left out is deleted). account_id moves the Draft to another of your accounts. Editing a failed Draft clears its failure.
+         */
+        patch: operations["patchV1DraftsId"];
+        trace?: never;
+    };
+    "/v1/drafts/{id}/publish": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Publish a draft now
+         * @description Publishes the Draft now, under the same rules as create post, safety limits included. Success deletes the Draft and its media, writes a publish record and returns the post id, no webhook. Failure leaves the Draft unchanged.
+         */
+        post: operations["postV1DraftsIdPublish"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/v1/drafts/{id}/attachments": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get?: never;
+        put?: never;
+        /**
+         * Upload a draft attachment
+         * @description Adds one file to the Draft as the raw request body, for media too large to send inline: a video (MP4, up to 50 MiB), a PDF (up to 50 MiB) or an image. Content-Type is the file's type, Content-Length is required; kept only if it arrives whole. Same media rules as inline.
+         */
+        post: operations["postV1DraftsIdAttachments"];
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/v1/{account_id}/recruiter/profiles/{user_id}": {
         parameters: {
             query?: never;
@@ -2390,8 +2491,8 @@ interface paths {
         options?: never;
         head?: never;
         /**
-         * Update account metadata / proxy configuration
-         * @description Updates an account's metadata (a flat string map, replaced wholesale) and/or its custom proxy egress; pass a proxy object to set one, or null to clear it. Credentials and seat are untouched.
+         * Update an account's metadata or connection location
+         * @description Updates metadata, external_id, the connection location (country) or your own proxy (null plus a country returns to a managed location). Returns the account; connection_location is re-read after a location change.
          */
         patch: operations["patchV1AccountsAccountId"];
         trace?: never;
@@ -2611,7 +2712,7 @@ interface paths {
         put?: never;
         /**
          * Create a webhook
-         * @description Registers a new webhook endpoint to receive real-time events. Choose a source (messaging / user / account_status) and supply the target URL. The HMAC signing secret is returned exactly once in the 201 response, store it securely.
+         * @description Registers a new webhook endpoint to receive real-time events. Choose a source (messaging / user / account_status / post) and supply the target URL. The HMAC signing secret is returned exactly once in the 201 response, store it securely.
          */
         post: operations["postV1Webhooks"];
         delete?: never;
@@ -2629,7 +2730,7 @@ interface paths {
         };
         /**
          * List webhook event types
-         * @description Returns the complete canonical event catalogue (27 events) grouped by source: messaging (7), user (2), account_status (15), plus 3 recruiter/sales_nav events. A local catalogue read: no platform call is made.
+         * @description Returns the complete canonical event catalogue (29 events) grouped by source: messaging (7), user (2), account_status (15), post (2), plus 3 recruiter/sales_nav events. A local catalogue read: no platform call is made.
          */
         get: operations["getV1WebhooksEvents"];
         put?: never;
@@ -2886,6 +2987,20 @@ interface components {
             challenge_type?: string;
             /** @description Present on ACCOUNT_ALREADY_LINKED: the id of your own existing account for this LinkedIn profile, so you can reuse it instead of linking again. Only ever an account of the calling tenant. */
             account_id?: string;
+            /** @description Present on CONNECTION_LOCATION_UNAVAILABLE after a location PATCH that did not land where asked: where the account connects from now (country, current_country, mode, strict), re-read after the change. */
+            connection_location?: {
+                /** @description Configured country (ISO 3166-1 alpha-2). */
+                country?: string | null;
+                /** @description Country of the connection in use now. */
+                current_country?: string | null;
+                /**
+                 * @description auto: managed. custom: your own proxy.
+                 * @enum {string|null}
+                 */
+                mode?: "auto" | "custom" | null;
+                /** @description true: never connects from another country. */
+                strict?: boolean | null;
+            };
             /** @description Present on RATE_LIMIT_ACCOUNT: the per-account request ceiling that was breached, with its name, the units remaining and total, and the absolute reset_time. Wait until reset_time before retrying. */
             quota?: Record<string, never>;
             /** @description Present on TOOLSET_DISABLED: the name of the toolset that is switched off for this tenant, so you can enable it or use another tool. */
@@ -6056,13 +6171,20 @@ interface operations {
                             id: string;
                             /** @description Shareable post URL. Present when available. */
                             share_url?: string;
-                            /** @description Post text content. Present when available. */
+                            /** @description Post text content. Present when available. Can repeat fragments around links, mentions and hashtags; get the post by its id for the clean body. */
                             text?: string;
+                            /** @description ISO-8601 UTC datetime the post was published, derived from the post's own activity identity (the same source as get-post's `created_at`). null when the result carries no activity identity to derive it from. */
+                            created_at: string | null;
                             /** @description Post author object. Present when available. */
                             author?: {
                                 id?: string;
+                                /** @description Author's display name, on the shape that carries `name`. Read `name` when present, else `display_name`. */
                                 name?: string | null;
+                                /** @description Author's display name, on the shape that carries `display_name` instead of `name`. */
+                                display_name?: string;
                                 is_company?: boolean;
+                                /** @description Author entity type (for example individual or organization), on the shape that carries `display_name`. */
+                                type?: string;
                                 public_identifier?: string | null;
                             } & {
                                 [key: string]: unknown;
@@ -9144,13 +9266,20 @@ interface operations {
                             id: string;
                             /** @description Shareable post URL. Present when available. */
                             share_url?: string;
-                            /** @description Post text content. Present when available. */
+                            /** @description Post text content. Present when available. Can repeat fragments around links, mentions and hashtags; get the post by its id for the clean body. */
                             text?: string;
+                            /** @description ISO-8601 UTC datetime the post was published, derived from the post's own activity identity (the same source as get-post's `created_at`). null when the result carries no activity identity to derive it from. */
+                            created_at: string | null;
                             /** @description Post author object. Present when available. */
                             author?: {
                                 id?: string;
+                                /** @description Author's display name, on the shape that carries `name`. Read `name` when present, else `display_name`. */
                                 name?: string | null;
+                                /** @description Author's display name, on the shape that carries `display_name` instead of `name`. */
+                                display_name?: string;
                                 is_company?: boolean;
+                                /** @description Author entity type (for example individual or organization), on the shape that carries `display_name`. */
+                                type?: string;
                                 public_identifier?: string | null;
                             } & {
                                 [key: string]: unknown;
@@ -9673,13 +9802,20 @@ interface operations {
                             id: string;
                             /** @description Shareable post URL. Present when available. */
                             share_url?: string;
-                            /** @description Post text content. Present when available. */
+                            /** @description Post text content. Present when available. Can repeat fragments around links, mentions and hashtags; get the post by its id for the clean body. */
                             text?: string;
+                            /** @description ISO-8601 UTC datetime the post was published, derived from the post's own activity identity (the same source as get-post's `created_at`). null when the result carries no activity identity to derive it from. */
+                            created_at: string | null;
                             /** @description Post author object. Present when available. */
                             author?: {
                                 id?: string;
+                                /** @description Author's display name, on the shape that carries `name`. Read `name` when present, else `display_name`. */
                                 name?: string | null;
+                                /** @description Author's display name, on the shape that carries `display_name` instead of `name`. */
+                                display_name?: string;
                                 is_company?: boolean;
+                                /** @description Author entity type (for example individual or organization), on the shape that carries `display_name`. */
+                                type?: string;
                                 public_identifier?: string | null;
                             } & {
                                 [key: string]: unknown;
@@ -13000,7 +13136,7 @@ interface operations {
         };
         requestBody?: never;
         responses: {
-            /** @description The connected account's home feed as agent-actionable posts. `sort=recent` (default) resolves each post's activity id + author name + post URL + kind; `sort=relevant` resolves the full shape (text, engagement, author id-triple). An empty feed is a valid 200 (items:[], cursor:null). Page until cursor is null. */
+            /** @description The connected account's home feed as agent-actionable posts. `sort=recent` (default) resolves each post's activity id + created_at + text + author name + post URL + kind, with engagement null; `sort=relevant` resolves the full shape (text, engagement, author id-triple). An empty feed is a valid 200 (items:[], cursor:null). Page until cursor is null. */
             200: {
                 headers: {
                     "RateLimit-Policy": components["headers"]["RateLimit-Policy"];
@@ -13047,8 +13183,10 @@ interface operations {
                                 /** @description Canonical profile URL. */
                                 profile_url: string | null;
                             };
-                            /** @description Full post body, verbatim (relevant). null on recent (the body is nested deep in the source). Pass-through, never stored. */
+                            /** @description Full post body, verbatim, on both sorts. null when the post has no body. Pass-through, never stored. */
                             text: string | null;
+                            /** @description ISO-8601 UTC datetime the feed activity was created, derived from the activity id (the same source as get-post's `created_at`). Both sorts. For a reshare this is when the reshare was made. null when the id does not carry a time. */
+                            created_at: string | null;
                             /** @description Canonical post URL (recent). null on relevant. */
                             post_url: string | null;
                             /** @description Post type parsed from the URL slug: ugcPost | share | groupPost | activity | post (recent). Open enum. null on relevant. */
@@ -13064,14 +13202,14 @@ interface operations {
                                 /** @description Original post body (pass-through; never stored). */
                                 text: string | null;
                             } | null;
-                            /** @description Engagement counts. All 0 on recent. */
+                            /** @description Engagement counts. Every count is null on recent, which cannot read them; use sort=relevant for counts. A null count is unknown, never zero. */
                             engagement: {
-                                /** @description Reaction count. Defaults 0. */
-                                likes: number;
-                                /** @description Comment count. Defaults 0. */
-                                comments: number;
-                                /** @description Reshare count. Defaults 0. */
-                                shares: number;
+                                /** @description Reaction count, or null when the sort cannot read it. */
+                                likes: number | null;
+                                /** @description Comment count, or null when the sort cannot read it. */
+                                comments: number | null;
+                                /** @description Reshare count, or null when the sort cannot read it. */
+                                shares: number | null;
                             };
                         }[];
                         /** @description Opaque cursor for the next page; null when the walk is exhausted. Self-describing of the sort, pass it back verbatim as `cursor`. The relevant cursor expires (~1h). There is no total (an unbounded, reordering stream); page until cursor is null. */
@@ -18126,7 +18264,7 @@ interface operations {
                         title?: string | null;
                         /** @description Full post text (content pass-through, never stored). */
                         text?: string | null;
-                        /** @description ISO-8601 UTC datetime this post was created, or null if unavailable. Derived from the post's own identity, so it does not change with the route you used to reach it. For a repost this is when the repost was made, not when the post it reshares was, so it is safe to sort by recency. */
+                        /** @description ISO-8601 UTC datetime this post was published, or null when it cannot be told reliably. Derived from the post's own activity identity, so it does not change with the route you used to reach it. null when the post carries no activity identity of its own (often a video or image post), never a guess. For a repost this is when the repost was made, not when the post it reshares was. */
                         created_at?: string | null;
                         /** @description Total comment count, or null when the platform hides it. */
                         comment_count?: number | null;
@@ -18610,7 +18748,7 @@ interface operations {
                             title?: string | null;
                             /** @description Full post text (content pass-through, never stored). */
                             text?: string | null;
-                            /** @description ISO-8601 UTC datetime this post was created, or null if unavailable. Derived from the post's own identity, so it does not change with the route you used to reach it. For a repost this is when the repost was made, not when the post it reshares was, so it is safe to sort by recency. */
+                            /** @description ISO-8601 UTC datetime this post was published, or null when it cannot be told reliably. Derived from the post's own activity identity, so it does not change with the route you used to reach it. null when the post carries no activity identity of its own (often a video or image post), never a guess. For a repost this is when the repost was made, not when the post it reshares was. */
                             created_at?: string | null;
                             /** @description Total comment count, or null when the platform hides it. */
                             comment_count?: number | null;
@@ -19613,7 +19751,1169 @@ interface operations {
                     "application/json": components["schemas"]["Error"];
                 };
             };
-            /** @description The account_id does not belong to this tenant (ACCOUNT_NOT_FOUND), or the target post was not found (RESOURCE_NOT_FOUND). An id whose connection was replaced or removed also stops resolving here, and it is already absent from the list, so re-read `GET /v1/accounts` for the current id. */
+            /** @description The account_id does not belong to this tenant (ACCOUNT_NOT_FOUND), or the target post was not found (RESOURCE_NOT_FOUND). An id whose connection was replaced or removed also stops resolving here, and it is already absent from the list, so re-read `GET /v1/accounts` for the current id. */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+            /** @description Payload too large, the request body exceeds the size limit. */
+            413: {
+                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 upstream error occurred, or the upstream response could not be interpreted. Check `retry_likely_to_succeed`: a temporary error is worth retrying, a response that could not be interpreted is not, and carries `retry_hint: {"kind": "never"}`. */
+            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"];
+                };
+            };
+        };
+    };
+    deleteV1AccountIdSavedPostsPostId: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description The account ID (`acc_...`) that performs the unsave. */
+                account_id: string;
+                /** @description The post's id from get_post or any list response. A bare activity id, a URN (activity/ugcPost/share), or a full share URL all work. */
+                post_id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description The post is no longer saved. Unsaving a not-currently-saved post just returns 200 again, not an error. */
+            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: "save_result";
+                        /** @description true after save_post, false after unsave_post. */
+                        saved: boolean;
+                        /** @description The target post's activity id, stripped of the urn:li:activity: prefix. */
+                        post_id: string;
+                        safety_warning?: components["schemas"]["SafetyWarning"];
+                    };
+                };
+            };
+            /** @description Missing/malformed account_id, or post_id is not in an accepted form (the `id` from a post read, a bare numeric activity id, a `urn:li:activity:<id>` URN, or a full LinkedIn post URL). */
+            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 Forbidden. NO_ACTIVE_SEAT: the account is not attached to an active seat. */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+            /** @description The account_id does not belong to this tenant (ACCOUNT_NOT_FOUND), or the target post was not found (RESOURCE_NOT_FOUND). An id whose connection was replaced or removed also stops resolving here, and it is already absent from the list, so re-read `GET /v1/accounts` for the current id. */
+            404: {
+                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 upstream error occurred, or the upstream response could not be interpreted. Check `retry_likely_to_succeed`: a temporary error is worth retrying, a response that could not be interpreted is not, and carries `retry_hint: {"kind": "never"}`. */
+            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"];
+                };
+            };
+        };
+    };
+    getV1Drafts: {
+        parameters: {
+            query?: {
+                /** @description Comma list of draft, scheduled, failed, published. Default draft,scheduled,failed. published items are publish records, never Drafts. */
+                status?: ("draft" | "scheduled" | "failed" | "published")[];
+                /** @description Only items on this account (acc_...), or none for Drafts with no account. Omitted: all of yours. */
+                account_id?: string;
+                /** @description Only items whose date is at or after this instant (inclusive). */
+                from?: string;
+                /** @description Only items whose date is before this instant (exclusive). */
+                to?: string;
+                /** @description Sort by the item's date: desc (default) or asc. */
+                order?: "desc" | "asc";
+                /** @description Max items per page (1-100, default 20). */
+                limit?: number;
+                /** @description Pagination cursor from a previous response; pass it back verbatim with the same filters. */
+                cursor?: string;
+            };
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Drafts and publish records, ordered by each item's own date: scheduled_at for scheduled, failure.failed_at for failed, published_at for published, updated_at for draft. */
+            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: "draft_list";
+                        /** @description Each item is a draft (object: draft) or a publish record (object: publish_record). Publish records are never Drafts. */
+                        items: ({
+                            /**
+                             * @description Response type discriminator.
+                             * @enum {string}
+                             */
+                            object: "draft";
+                            /** @description Draft id (drf_...). */
+                            id: string;
+                            /** @description The account this Draft will publish as, or null for none yet. */
+                            account_id: string | null;
+                            /**
+                             * @description Derived: failed if failure is set, else scheduled if scheduled_at is set, else draft.
+                             * @enum {string}
+                             */
+                            status: "draft" | "scheduled" | "failed";
+                            /** @description Post body text. May be empty or null while drafting. */
+                            text: string | null;
+                            /** @description Media, in post order. */
+                            attachments: {
+                                /** @description Attachment id (att_...). Send {id} in a PATCH attachments list to keep it. */
+                                id: string;
+                                /** @description The file's type. */
+                                content_type: string;
+                                /** @description File name. */
+                                filename: string;
+                                /** @description Stored size in bytes. */
+                                size_bytes: number;
+                                /** @description Signed download link to the stored file, valid for 1 hour. Read the Draft again for a fresh one. Null when the stored file is unavailable. */
+                                url: string | null;
+                            }[];
+                            /** @description A post to quote or repost when published. */
+                            quoted_post_id?: string | null;
+                            /**
+                             * @description Who can read the post once published.
+                             * @enum {string|null}
+                             */
+                            can_read?: "anyone" | "relations_only" | null;
+                            /**
+                             * @description Who may comment once published.
+                             * @enum {string|null}
+                             */
+                            can_comment?: "anyone" | "relations_only" | "no_one" | null;
+                            /** @description Company page id to post as. */
+                            post_as?: string | null;
+                            /** @description When Curviate publishes the Draft (UTC, whole minute), or null. It goes out up to 20 seconds after this time. A failed Draft has null here; the time that failed is failure.scheduled_at. */
+                            scheduled_at: string | null;
+                            /** @description Why the last scheduled publish failed; present on failed Drafts only. */
+                            failure: {
+                                /**
+                                 * @description Why it failed. outcome_unknown: the platform gave no usable answer, so the post may be live; check the account's posts before you publish again. missed: Curviate could not start within an hour of the time. platform_error and rate_limited: 3 attempts over about 15 minutes all failed.
+                                 * @enum {string}
+                                 */
+                                code?: "platform_error" | "rate_limited" | "account_unavailable" | "media_rejected" | "budget_exhausted" | "outside_activity_window" | "no_active_seat" | "not_publishable" | "platform_rejected" | "missed" | "outcome_unknown";
+                                /** @description What went wrong and what to do next. Never contains post text. */
+                                message?: string;
+                                /** @description When it failed. */
+                                failed_at?: string;
+                                /** @description The time that failed to publish. */
+                                scheduled_at?: string;
+                            } | null;
+                            /** @description Creation time. */
+                            created_at: string;
+                            /** @description Last change. */
+                            updated_at: string;
+                        } | {
+                            /**
+                             * @description Response type discriminator.
+                             * @enum {string}
+                             */
+                            object: "publish_record";
+                            /** @description The published post's id, or null when the platform returned none. */
+                            post_id: string | null;
+                            /** @description The account that published it. */
+                            account_id: string;
+                            /** @description When it was published. */
+                            published_at: string;
+                            /** @description The Draft it came from, or null for a post created directly. */
+                            draft_id: string | null;
+                        })[];
+                        /** @description Pass back as cursor for the next page; null on the last page. */
+                        cursor: string | null;
+                        safety_warning?: components["schemas"]["SafetyWarning"];
+                    };
+                };
+            };
+            /** @description Invalid filter: an unknown status, a malformed date or cursor, or limit out of range. */
+            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 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"];
+                };
+            };
+        };
+    };
+    postV1Drafts: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": {
+                    /** @description The account (acc_...) this Draft will publish as, or null for none yet. A Draft belongs to at most one account. */
+                    account_id?: string | null;
+                    /** @description When Curviate publishes this Draft: an ISO 8601 date-time with an offset, at least 5 minutes and at most 365 days ahead, stored in UTC truncated to the minute. Scheduling needs an account and text. Curviate publishes it up to 20 seconds after this time, and keeps scheduled posts on one account at least 5 minutes apart. null unschedules. */
+                    scheduled_at?: string | null;
+                    /** @description Post body text, up to 3000 characters. May be empty while drafting; publishing needs at least one character. */
+                    text?: string | null;
+                    /** @description A post to quote or repost when published, the same as on create post. Checked at publish time. */
+                    quoted_post_id?: string | null;
+                    /**
+                     * @description Who can read the post once published.
+                     * @enum {string|null}
+                     */
+                    can_read?: "anyone" | "relations_only" | null;
+                    /**
+                     * @description Who may comment once published.
+                     * @enum {string|null}
+                     */
+                    can_comment?: "anyone" | "relations_only" | "no_one" | null;
+                    /** @description Company page id to post as; the account must administer it. Checked at publish time. */
+                    post_as?: string | null;
+                    /** @description Media as base64 objects: up to 20 images, or one MP4 video, or one PDF, never mixed. 5 MiB per file inline. */
+                    attachments?: {
+                        /** @description Base64-encoded file bytes. */
+                        content: string;
+                        /** @description The file's type: image/jpeg, image/png, image/gif, image/webp, video/mp4 or application/pdf. */
+                        content_type: string;
+                        /** @description File name. */
+                        filename: string;
+                    }[];
+                };
+            };
+        };
+        responses: {
+            /** @description Draft created. With scheduled_at, status is scheduled and Curviate publishes it on its own. With scheduled_at, the response carries safety_warning (reason activity_window) when the time is outside the account's activity window and its posture is warn; under enforce the request is refused instead (429 BUDGET_EXHAUSTED, reason activity_window) and nothing is saved. */
+            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: "draft";
+                        /** @description Draft id (drf_...). */
+                        id: string;
+                        /** @description The account this Draft will publish as, or null for none yet. */
+                        account_id: string | null;
+                        /**
+                         * @description Derived: failed if failure is set, else scheduled if scheduled_at is set, else draft.
+                         * @enum {string}
+                         */
+                        status: "draft" | "scheduled" | "failed";
+                        /** @description Post body text. May be empty or null while drafting. */
+                        text: string | null;
+                        /** @description Media, in post order. */
+                        attachments: {
+                            /** @description Attachment id (att_...). Send {id} in a PATCH attachments list to keep it. */
+                            id: string;
+                            /** @description The file's type. */
+                            content_type: string;
+                            /** @description File name. */
+                            filename: string;
+                            /** @description Stored size in bytes. */
+                            size_bytes: number;
+                            /** @description Signed download link to the stored file, valid for 1 hour. Read the Draft again for a fresh one. Null when the stored file is unavailable. */
+                            url: string | null;
+                        }[];
+                        /** @description A post to quote or repost when published. */
+                        quoted_post_id?: string | null;
+                        /**
+                         * @description Who can read the post once published.
+                         * @enum {string|null}
+                         */
+                        can_read?: "anyone" | "relations_only" | null;
+                        /**
+                         * @description Who may comment once published.
+                         * @enum {string|null}
+                         */
+                        can_comment?: "anyone" | "relations_only" | "no_one" | null;
+                        /** @description Company page id to post as. */
+                        post_as?: string | null;
+                        /** @description When Curviate publishes the Draft (UTC, whole minute), or null. It goes out up to 20 seconds after this time. A failed Draft has null here; the time that failed is failure.scheduled_at. */
+                        scheduled_at: string | null;
+                        /** @description Why the last scheduled publish failed; present on failed Drafts only. */
+                        failure: {
+                            /**
+                             * @description Why it failed. outcome_unknown: the platform gave no usable answer, so the post may be live; check the account's posts before you publish again. missed: Curviate could not start within an hour of the time. platform_error and rate_limited: 3 attempts over about 15 minutes all failed.
+                             * @enum {string}
+                             */
+                            code?: "platform_error" | "rate_limited" | "account_unavailable" | "media_rejected" | "budget_exhausted" | "outside_activity_window" | "no_active_seat" | "not_publishable" | "platform_rejected" | "missed" | "outcome_unknown";
+                            /** @description What went wrong and what to do next. Never contains post text. */
+                            message?: string;
+                            /** @description When it failed. */
+                            failed_at?: string;
+                            /** @description The time that failed to publish. */
+                            scheduled_at?: string;
+                        } | null;
+                        /** @description Creation time. */
+                        created_at: string;
+                        /** @description Last change. */
+                        updated_at: string;
+                        safety_warning?: components["schemas"]["SafetyWarning"];
+                    };
+                };
+            };
+            /** @description Invalid input. Media rules: up to 20 images (JPEG, PNG, GIF, WEBP, at most 6012 x 6012 px), or one MP4 video, or one PDF, never mixed. scheduled_at must be an ISO 8601 date-time with an offset, 5 minutes to 365 days ahead after truncation to the minute. */
+            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 Forbidden. NO_ACTIVE_SEAT: the account is not attached to an active seat. */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+            /** @description The account_id is not one of yours (ACCOUNT_NOT_FOUND). */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+            /** @description The account is disconnected (REAUTH_REQUIRED). Reconnect it, or choose another account. */
+            409: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+            /** @description A file is over its size limit: 5 MiB per image, and 5 MiB per file sent inline. */
+            413: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+            /** @description DRAFT_LIMIT_REACHED: the bucket (one account, or Drafts with no account) already holds 50 Drafts. MEDIA_QUOTA_EXCEEDED: the media would take the bucket past its 2 GiB quota; nothing is stored. ACCOUNT_REQUIRED / DRAFT_NOT_PUBLISHABLE: scheduling needs an account and text. SCHEDULE_CONFLICT: another scheduled Draft on the account is less than 5 minutes away; the message names it. */
+            422: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+            /** @description BUDGET_EXHAUSTED with reason activity_window: the scheduled time is outside the account's activity window and the account enforces it. Nothing is saved. */
+            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"];
+                };
+            };
+        };
+    };
+    getV1DraftsId: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description Draft id (drf_...). */
+                id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description The Draft. */
+            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: "draft";
+                        /** @description Draft id (drf_...). */
+                        id: string;
+                        /** @description The account this Draft will publish as, or null for none yet. */
+                        account_id: string | null;
+                        /**
+                         * @description Derived: failed if failure is set, else scheduled if scheduled_at is set, else draft.
+                         * @enum {string}
+                         */
+                        status: "draft" | "scheduled" | "failed";
+                        /** @description Post body text. May be empty or null while drafting. */
+                        text: string | null;
+                        /** @description Media, in post order. */
+                        attachments: {
+                            /** @description Attachment id (att_...). Send {id} in a PATCH attachments list to keep it. */
+                            id: string;
+                            /** @description The file's type. */
+                            content_type: string;
+                            /** @description File name. */
+                            filename: string;
+                            /** @description Stored size in bytes. */
+                            size_bytes: number;
+                            /** @description Signed download link to the stored file, valid for 1 hour. Read the Draft again for a fresh one. Null when the stored file is unavailable. */
+                            url: string | null;
+                        }[];
+                        /** @description A post to quote or repost when published. */
+                        quoted_post_id?: string | null;
+                        /**
+                         * @description Who can read the post once published.
+                         * @enum {string|null}
+                         */
+                        can_read?: "anyone" | "relations_only" | null;
+                        /**
+                         * @description Who may comment once published.
+                         * @enum {string|null}
+                         */
+                        can_comment?: "anyone" | "relations_only" | "no_one" | null;
+                        /** @description Company page id to post as. */
+                        post_as?: string | null;
+                        /** @description When Curviate publishes the Draft (UTC, whole minute), or null. It goes out up to 20 seconds after this time. A failed Draft has null here; the time that failed is failure.scheduled_at. */
+                        scheduled_at: string | null;
+                        /** @description Why the last scheduled publish failed; present on failed Drafts only. */
+                        failure: {
+                            /**
+                             * @description Why it failed. outcome_unknown: the platform gave no usable answer, so the post may be live; check the account's posts before you publish again. missed: Curviate could not start within an hour of the time. platform_error and rate_limited: 3 attempts over about 15 minutes all failed.
+                             * @enum {string}
+                             */
+                            code?: "platform_error" | "rate_limited" | "account_unavailable" | "media_rejected" | "budget_exhausted" | "outside_activity_window" | "no_active_seat" | "not_publishable" | "platform_rejected" | "missed" | "outcome_unknown";
+                            /** @description What went wrong and what to do next. Never contains post text. */
+                            message?: string;
+                            /** @description When it failed. */
+                            failed_at?: string;
+                            /** @description The time that failed to publish. */
+                            scheduled_at?: string;
+                        } | null;
+                        /** @description Creation time. */
+                        created_at: string;
+                        /** @description Last change. */
+                        updated_at: string;
+                        safety_warning?: components["schemas"]["SafetyWarning"];
+                    };
+                };
+            };
+            /** @description Missing or invalid API key. */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+            /** @description No Draft with this id among yours (RESOURCE_NOT_FOUND). */
+            404: {
+                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"];
+                };
+            };
+        };
+    };
+    deleteV1DraftsId: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description Draft id (drf_...). */
+                id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Draft and its media deleted. No response body. */
+            204: {
+                headers: {
+                    "RateLimit-Policy": components["headers"]["RateLimit-Policy"];
+                    RateLimit: components["headers"]["RateLimit"];
+                    [name: string]: unknown;
+                };
+                content?: never;
+            };
+            /** @description Missing or invalid API key. */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+            /** @description No Draft with this id among yours (RESOURCE_NOT_FOUND). */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+            /** @description DRAFT_PUBLISHING: a publish of this Draft is in flight. Read it again in a few seconds. */
+            409: {
+                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"];
+                };
+            };
+        };
+    };
+    patchV1DraftsId: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description Draft id (drf_...). */
+                id: string;
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "application/json": {
+                    /** @description The account (acc_...) this Draft will publish as, or null for none yet. A Draft belongs to at most one account. */
+                    account_id?: string | null;
+                    /** @description When Curviate publishes this Draft: an ISO 8601 date-time with an offset, at least 5 minutes and at most 365 days ahead, stored in UTC truncated to the minute. Scheduling needs an account and text. Curviate publishes it up to 20 seconds after this time, and keeps scheduled posts on one account at least 5 minutes apart. null unschedules. */
+                    scheduled_at?: string | null;
+                    /** @description Post body text, up to 3000 characters. May be empty while drafting; publishing needs at least one character. */
+                    text?: string | null;
+                    /** @description A post to quote or repost when published, the same as on create post. Checked at publish time. */
+                    quoted_post_id?: string | null;
+                    /**
+                     * @description Who can read the post once published.
+                     * @enum {string|null}
+                     */
+                    can_read?: "anyone" | "relations_only" | null;
+                    /**
+                     * @description Who may comment once published.
+                     * @enum {string|null}
+                     */
+                    can_comment?: "anyone" | "relations_only" | "no_one" | null;
+                    /** @description Company page id to post as; the account must administer it. Checked at publish time. */
+                    post_as?: string | null;
+                    /** @description Replaces the whole list. Each item is {id} to keep an existing attachment, or a new base64 object. Attachments left out are deleted. */
+                    attachments?: ({
+                        /** @description An attachment already on this Draft (att_...), kept as is. */
+                        id: string;
+                    } | {
+                        /** @description Base64-encoded file bytes. */
+                        content: string;
+                        /** @description The file's type: image/jpeg, image/png, image/gif, image/webp, video/mp4 or application/pdf. */
+                        content_type: string;
+                        /** @description File name. */
+                        filename: string;
+                    })[];
+                };
+            };
+        };
+        responses: {
+            /** @description The updated Draft. scheduled_at schedules, reschedules or (null) unschedules; changing it or the account cancels a pending publish and its retries. Unscheduling alone needs no active seat. With scheduled_at, the response carries safety_warning (reason activity_window) when the time is outside the account's activity window and its posture is warn; under enforce the request is refused instead (429 BUDGET_EXHAUSTED, reason activity_window) and nothing is saved. */
+            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: "draft";
+                        /** @description Draft id (drf_...). */
+                        id: string;
+                        /** @description The account this Draft will publish as, or null for none yet. */
+                        account_id: string | null;
+                        /**
+                         * @description Derived: failed if failure is set, else scheduled if scheduled_at is set, else draft.
+                         * @enum {string}
+                         */
+                        status: "draft" | "scheduled" | "failed";
+                        /** @description Post body text. May be empty or null while drafting. */
+                        text: string | null;
+                        /** @description Media, in post order. */
+                        attachments: {
+                            /** @description Attachment id (att_...). Send {id} in a PATCH attachments list to keep it. */
+                            id: string;
+                            /** @description The file's type. */
+                            content_type: string;
+                            /** @description File name. */
+                            filename: string;
+                            /** @description Stored size in bytes. */
+                            size_bytes: number;
+                            /** @description Signed download link to the stored file, valid for 1 hour. Read the Draft again for a fresh one. Null when the stored file is unavailable. */
+                            url: string | null;
+                        }[];
+                        /** @description A post to quote or repost when published. */
+                        quoted_post_id?: string | null;
+                        /**
+                         * @description Who can read the post once published.
+                         * @enum {string|null}
+                         */
+                        can_read?: "anyone" | "relations_only" | null;
+                        /**
+                         * @description Who may comment once published.
+                         * @enum {string|null}
+                         */
+                        can_comment?: "anyone" | "relations_only" | "no_one" | null;
+                        /** @description Company page id to post as. */
+                        post_as?: string | null;
+                        /** @description When Curviate publishes the Draft (UTC, whole minute), or null. It goes out up to 20 seconds after this time. A failed Draft has null here; the time that failed is failure.scheduled_at. */
+                        scheduled_at: string | null;
+                        /** @description Why the last scheduled publish failed; present on failed Drafts only. */
+                        failure: {
+                            /**
+                             * @description Why it failed. outcome_unknown: the platform gave no usable answer, so the post may be live; check the account's posts before you publish again. missed: Curviate could not start within an hour of the time. platform_error and rate_limited: 3 attempts over about 15 minutes all failed.
+                             * @enum {string}
+                             */
+                            code?: "platform_error" | "rate_limited" | "account_unavailable" | "media_rejected" | "budget_exhausted" | "outside_activity_window" | "no_active_seat" | "not_publishable" | "platform_rejected" | "missed" | "outcome_unknown";
+                            /** @description What went wrong and what to do next. Never contains post text. */
+                            message?: string;
+                            /** @description When it failed. */
+                            failed_at?: string;
+                            /** @description The time that failed to publish. */
+                            scheduled_at?: string;
+                        } | null;
+                        /** @description Creation time. */
+                        created_at: string;
+                        /** @description Last change. */
+                        updated_at: string;
+                        safety_warning?: components["schemas"]["SafetyWarning"];
+                    };
+                };
+            };
+            /** @description Invalid input. Media rules: up to 20 images (JPEG, PNG, GIF, WEBP, at most 6012 x 6012 px), or one MP4 video, or one PDF, never mixed. Also: an attachment id that is not on this Draft. scheduled_at must be an ISO 8601 date-time with an offset, 5 minutes to 365 days ahead after truncation to the minute. */
+            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 Forbidden. NO_ACTIVE_SEAT: the account is not attached to an active seat. */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+            /** @description No such Draft (RESOURCE_NOT_FOUND), or the account_id is not one of yours (ACCOUNT_NOT_FOUND). */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+            /** @description DRAFT_PUBLISHING: a publish of this Draft is in flight. Read it again in a few seconds. Or the target account is disconnected (REAUTH_REQUIRED). */
+            409: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+            /** @description A file is over its size limit: 5 MiB per image, and 5 MiB per file sent inline. */
+            413: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+            /** @description DRAFT_LIMIT_REACHED: the bucket (one account, or Drafts with no account) already holds 50 Drafts. MEDIA_QUOTA_EXCEEDED: the media would take the bucket past its 2 GiB quota; nothing is stored. ACCOUNT_REQUIRED: a scheduled Draft cannot drop its account; unschedule it first. ACCOUNT_REQUIRED / DRAFT_NOT_PUBLISHABLE: scheduling needs an account and text. SCHEDULE_CONFLICT: another scheduled Draft on the account is less than 5 minutes away; the message names it. */
+            422: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+            /** @description BUDGET_EXHAUSTED with reason activity_window: the scheduled time is outside the account's activity window and the account enforces it. Nothing is saved. */
+            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"];
+                };
+            };
+        };
+    };
+    postV1DraftsIdPublish: {
+        parameters: {
+            query?: never;
+            header?: never;
+            path: {
+                /** @description Draft id (drf_...). */
+                id: string;
+            };
+            cookie?: never;
+        };
+        requestBody?: never;
+        responses: {
+            /** @description Published. The Draft and its media are deleted and a publish record is written. No webhook is sent: this response is the result. */
+            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: "post_created";
+                        /** @description The published post's id. */
+                        id: string | null;
+                        safety_warning?: components["schemas"]["SafetyWarning"];
+                    };
+                };
+            };
+            /** @description Missing or invalid API key. */
+            401: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+            /** @description Forbidden. NO_ACTIVE_SEAT: the account is not attached to an active seat. */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+            /** @description No Draft with this id among yours (RESOURCE_NOT_FOUND). */
+            404: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+            /** @description DRAFT_PUBLISHING: a publish of this Draft is in flight. Read it again in a few seconds. */
+            409: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+            /** @description ACCOUNT_REQUIRED: the Draft has no account. DRAFT_NOT_PUBLISHABLE: a content gap, the message names the field (for example text: empty). The Draft is unchanged. */
+            422: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+            /** @description An account-safety limit or a platform rate limit refused the publish. The Draft is unchanged. */
+            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 The platform refused or failed the publish. The Draft is unchanged; the error says whether a retry can help. */
+            502: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+            /** @description PLATFORM_ERROR: the platform did not answer in time. The Draft is unchanged, but the post may still have been published: check the account's posts before publishing again. */
+            504: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+        };
+    };
+    postV1DraftsIdAttachments: {
+        parameters: {
+            query: {
+                /** @description The file's name, kept with the attachment. */
+                filename: string;
+            };
+            header?: never;
+            path: {
+                /** @description Draft id (drf_...). */
+                id: string;
+            };
+            cookie?: never;
+        };
+        requestBody: {
+            content: {
+                "video/mp4": string;
+                "application/pdf": string;
+                "image/jpeg": string;
+                "image/png": string;
+                "image/gif": string;
+                "image/webp": string;
+            };
+        };
+        responses: {
+            /** @description The Draft, with the new attachment last in attachments[]. */
+            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: "draft";
+                        /** @description Draft id (drf_...). */
+                        id: string;
+                        /** @description The account this Draft will publish as, or null for none yet. */
+                        account_id: string | null;
+                        /**
+                         * @description Derived: failed if failure is set, else scheduled if scheduled_at is set, else draft.
+                         * @enum {string}
+                         */
+                        status: "draft" | "scheduled" | "failed";
+                        /** @description Post body text. May be empty or null while drafting. */
+                        text: string | null;
+                        /** @description Media, in post order. */
+                        attachments: {
+                            /** @description Attachment id (att_...). Send {id} in a PATCH attachments list to keep it. */
+                            id: string;
+                            /** @description The file's type. */
+                            content_type: string;
+                            /** @description File name. */
+                            filename: string;
+                            /** @description Stored size in bytes. */
+                            size_bytes: number;
+                            /** @description Signed download link to the stored file, valid for 1 hour. Read the Draft again for a fresh one. Null when the stored file is unavailable. */
+                            url: string | null;
+                        }[];
+                        /** @description A post to quote or repost when published. */
+                        quoted_post_id?: string | null;
+                        /**
+                         * @description Who can read the post once published.
+                         * @enum {string|null}
+                         */
+                        can_read?: "anyone" | "relations_only" | null;
+                        /**
+                         * @description Who may comment once published.
+                         * @enum {string|null}
+                         */
+                        can_comment?: "anyone" | "relations_only" | "no_one" | null;
+                        /** @description Company page id to post as. */
+                        post_as?: string | null;
+                        /** @description When Curviate publishes the Draft (UTC, whole minute), or null. It goes out up to 20 seconds after this time. A failed Draft has null here; the time that failed is failure.scheduled_at. */
+                        scheduled_at: string | null;
+                        /** @description Why the last scheduled publish failed; present on failed Drafts only. */
+                        failure: {
+                            /**
+                             * @description Why it failed. outcome_unknown: the platform gave no usable answer, so the post may be live; check the account's posts before you publish again. missed: Curviate could not start within an hour of the time. platform_error and rate_limited: 3 attempts over about 15 minutes all failed.
+                             * @enum {string}
+                             */
+                            code?: "platform_error" | "rate_limited" | "account_unavailable" | "media_rejected" | "budget_exhausted" | "outside_activity_window" | "no_active_seat" | "not_publishable" | "platform_rejected" | "missed" | "outcome_unknown";
+                            /** @description What went wrong and what to do next. Never contains post text. */
+                            message?: string;
+                            /** @description When it failed. */
+                            failed_at?: string;
+                            /** @description The time that failed to publish. */
+                            scheduled_at?: string;
+                        } | null;
+                        /** @description Creation time. */
+                        created_at: string;
+                        /** @description Last change. */
+                        updated_at: string;
+                        safety_warning?: components["schemas"]["SafetyWarning"];
+                    };
+                };
+            };
+            /** @description Invalid input. Media rules: up to 20 images (JPEG, PNG, GIF, WEBP, at most 6012 x 6012 px), or one MP4 video, or one PDF, never mixed. Also: an empty file, a filename missing, or a body that did not carry exactly its Content-Length (a truncated upload; nothing is kept). */
+            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 Forbidden. NO_ACTIVE_SEAT: the account is not attached to an active seat. */
+            403: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
+            /** @description No Draft with this id among yours (RESOURCE_NOT_FOUND). */
             404: {
                 headers: {
                     [name: string]: unknown;
@@ -19622,47 +20922,8 @@ interface operations {
                     "application/json": components["schemas"]["Error"];
                 };
             };
-            /** @description Payload too large, the request body exceeds the size limit. */
-            413: {
-                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 upstream error occurred, or the upstream response could not be interpreted. Check `retry_likely_to_succeed`: a temporary error is worth retrying, a response that could not be interpreted is not, and carries `retry_hint: {"kind": "never"}`. */
-            502: {
-                headers: {
-                    [name: string]: unknown;
-                };
-                content: {
-                    "application/json": components["schemas"]["Error"];
-                };
-            };
-            /** @description Service unavailable. */
-            503: {
+            /** @description DRAFT_PUBLISHING: a publish of this Draft is in flight. Read it again in a few seconds. */
+            409: {
                 headers: {
                     [name: string]: unknown;
                 };
@@ -19670,8 +20931,8 @@ interface operations {
                     "application/json": components["schemas"]["Error"];
                 };
             };
-            /** @description Gateway timeout. */
-            504: {
+            /** @description INVALID_REQUEST: Content-Length is required; a chunked upload is not accepted. */
+            411: {
                 headers: {
                     [name: string]: unknown;
                 };
@@ -19679,55 +20940,8 @@ interface operations {
                     "application/json": components["schemas"]["Error"];
                 };
             };
-        };
-    };
-    deleteV1AccountIdSavedPostsPostId: {
-        parameters: {
-            query?: never;
-            header?: never;
-            path: {
-                /** @description The account ID (`acc_...`) that performs the unsave. */
-                account_id: string;
-                /** @description The post's id from get_post or any list response. A bare activity id, a URN (activity/ugcPost/share), or a full share URL all work. */
-                post_id: string;
-            };
-            cookie?: never;
-        };
-        requestBody?: never;
-        responses: {
-            /** @description The post is no longer saved. Unsaving a not-currently-saved post just returns 200 again, not an error. */
-            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: "save_result";
-                        /** @description true after save_post, false after unsave_post. */
-                        saved: boolean;
-                        /** @description The target post's activity id, stripped of the urn:li:activity: prefix. */
-                        post_id: string;
-                        safety_warning?: components["schemas"]["SafetyWarning"];
-                    };
-                };
-            };
-            /** @description Missing/malformed account_id, or post_id is not in an accepted form (the `id` from a post read, a bare numeric activity id, a `urn:li:activity:<id>` URN, or a full LinkedIn post URL). */
-            400: {
-                headers: {
-                    [name: string]: unknown;
-                };
-                content: {
-                    "application/json": components["schemas"]["Error"];
-                };
-            };
-            /** @description Missing or invalid API key. */
-            401: {
+            /** @description PAYLOAD_TOO_LARGE: the file is over its type's limit: 5 MiB per image, 50 MiB for a video, 50 MiB for a PDF. */
+            413: {
                 headers: {
                     [name: string]: unknown;
                 };
@@ -19735,8 +20949,8 @@ interface operations {
                     "application/json": components["schemas"]["Error"];
                 };
             };
-            /** @description Forbidden. NO_ACTIVE_SEAT: the account is not attached to an active seat. */
-            403: {
+            /** @description UNSUPPORTED_MEDIA_TYPE: Content-Type is not one of the accepted file types (JSON and multipart bodies included). */
+            415: {
                 headers: {
                     [name: string]: unknown;
                 };
@@ -19744,8 +20958,8 @@ interface operations {
                     "application/json": components["schemas"]["Error"];
                 };
             };
-            /** @description The account_id does not belong to this tenant (ACCOUNT_NOT_FOUND), or the target post was not found (RESOURCE_NOT_FOUND). An id whose connection was replaced or removed also stops resolving here, and it is already absent from the list, so re-read `GET /v1/accounts` for the current id. */
-            404: {
+            /** @description MEDIA_QUOTA_EXCEEDED: the file would take the bucket past its 2 GiB quota; nothing is stored. */
+            422: {
                 headers: {
                     [name: string]: unknown;
                 };
@@ -19765,42 +20979,6 @@ interface operations {
                     "application/json": components["schemas"]["Error"];
                 };
             };
-            /** @description Internal error. */
-            500: {
-                headers: {
-                    [name: string]: unknown;
-                };
-                content: {
-                    "application/json": components["schemas"]["Error"];
-                };
-            };
-            /** @description A temporary upstream error occurred, or the upstream response could not be interpreted. Check `retry_likely_to_succeed`: a temporary error is worth retrying, a response that could not be interpreted is not, and carries `retry_hint: {"kind": "never"}`. */
-            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"];
-                };
-            };
         };
     };
     getV1AccountIdRecruiterProfilesUserId: {
@@ -27958,6 +29136,20 @@ interface operations {
                         items?: {
                             /** @description Curviate account id (acc_...). */
                             account_id?: string;
+                            /** @description Where LinkedIn sees this account connecting from. country: the configured country (ISO 3166-1 alpha-2), the one the account is set to use. current_country: the country of the connection in use right now; it differs from country only after a fallback, which can happen only when strict is false. mode: auto (a managed connection in country) or custom (your own proxy). strict: true when the account never connects from another country, null when unknown. Each field is null until known; an account connected through ip or your own proxy may show null until the next background refresh. Change it with PATCH /v1/accounts/{account_id} (country), or by reconnecting with country. */
+                            connection_location?: {
+                                /** @description Configured country (ISO 3166-1 alpha-2). */
+                                country?: string | null;
+                                /** @description Country of the connection in use right now. */
+                                current_country?: string | null;
+                                /**
+                                 * @description auto: managed connection. custom: your own proxy.
+                                 * @enum {string|null}
+                                 */
+                                mode?: "auto" | "custom" | null;
+                                /** @description true: never connects from another country. */
+                                strict?: boolean | null;
+                            };
                             /**
                              * @description Stable status whitelist.
                              * @enum {string}
@@ -28093,6 +29285,20 @@ interface operations {
                         metadata?: {
                             [key: string]: string;
                         } | null;
+                        /** @description Where LinkedIn sees this account connecting from. country: the configured country (ISO 3166-1 alpha-2), the one the account is set to use. current_country: the country of the connection in use right now; it differs from country only after a fallback, which can happen only when strict is false. mode: auto (a managed connection in country) or custom (your own proxy). strict: true when the account never connects from another country, null when unknown. Each field is null until known; an account connected through ip or your own proxy may show null until the next background refresh. Change it with PATCH /v1/accounts/{account_id} (country), or by reconnecting with country. */
+                        connection_location?: {
+                            /** @description Configured country (ISO 3166-1 alpha-2). */
+                            country?: string | null;
+                            /** @description Country of the connection in use right now. */
+                            current_country?: string | null;
+                            /**
+                             * @description auto: managed connection. custom: your own proxy.
+                             * @enum {string|null}
+                             */
+                            mode?: "auto" | "custom" | null;
+                            /** @description true: never connects from another country. */
+                            strict?: boolean | null;
+                        };
                         /** @description ISO-8601 UTC creation timestamp of the underlying LinkedIn account, distinct from connected_at. Null until the first background enrichment lands. */
                         substrate_created_at?: string | null;
                         /** @description Account-safety rows for this account: one entry per counted action for the current window of its grain, plus the derived total and the invitation backlog. Each row reports where the account stands, what it is allowed, which band that puts it in, what happens at the ceiling, whether the ceiling was raised above the Curviate default, and any active pause the platform caused. Whether a breach is refused or merely reported is `posture`, and the default is to report: nothing here refuses until you configure it to. Pacing is still the caller's responsibility, and nothing on this array paces for you. The per-minute REQUEST ceiling is a different thing and is deliberately not in this array: it protects Curviate's own servers rather than your LinkedIn account, it counts requests where these count platform operations, it is always enforced with HTTP 429 whatever your posture, and its envelope is returned on that refusal. Read this array to see where the account stands; read the safety events surface to see what has already been refused or flagged. */
@@ -28362,27 +29568,34 @@ interface operations {
                     } | null;
                     /** @description Your own id for this account's end user (1-255 chars), or null to clear it. Omit to leave it unchanged. */
                     external_id?: string | null;
-                    /** @description Custom-proxy egress config, or null to clear it (revert to automatic proxy protection). Omit to leave it unchanged. */
+                    /** @description Your own proxy, or null to stop using it and return to a managed location (null requires country in the same request). Omit to leave it unchanged. */
                     proxy?: {
                         /**
-                         * @description Proxy protocol. One of http, https, socks5.
+                         * @description Proxy protocol. One of http, https, socks5, socks4.
                          * @enum {string}
                          */
-                        protocol: "http" | "https" | "socks5";
+                        protocol: "http" | "https" | "socks5" | "socks4";
                         /** @description Proxy host or IP. */
                         host: string;
                         /** @description Proxy port (1-65535). */
                         port: number;
                         /** @description Proxy auth username (optional). */
                         username?: string;
-                        /** @description Proxy auth password (optional). Encrypted at rest, never logged or returned. */
+                        /** @description Proxy auth password (optional). Passed to the connection only: never stored, logged or returned. */
                         password?: string;
                     } | null;
+                    /**
+                     * @description Move this account's connection location to this supported ISO 3166-1 alpha-2 country (e.g. US, DE). LinkedIn sees a new IP in that country and may ask the owner to verify, so change it only when the current location is wrong. Strict unless allow_country_fallback is true. On an account using your own proxy, send proxy: null with it.
+                     * @enum {string}
+                     */
+                    country?: "AE" | "AO" | "AR" | "AT" | "AU" | "BD" | "BE" | "BG" | "BR" | "CA" | "CH" | "CL" | "CN" | "CO" | "CY" | "CZ" | "DE" | "DK" | "EE" | "EG" | "ES" | "FI" | "FR" | "GB" | "GT" | "HK" | "ID" | "IE" | "IL" | "IN" | "IT" | "JP" | "KR" | "KZ" | "MA" | "MX" | "MY" | "NL" | "NO" | "PA" | "PH" | "PK" | "PL" | "PR" | "PT" | "RO" | "SA" | "SE" | "SG" | "TH" | "TN" | "TR" | "UA" | "US" | "VN" | "ZA";
+                    /** @description Optional. false (the default with country or ip): only ever connect from that country; a connect fails when no connection is free there. true: a connection from another country may be used when none is free in the chosen one. Not accepted with proxy. */
+                    allow_country_fallback?: boolean;
                 };
             };
         };
         responses: {
-            /** @description The account was updated. metadata and external_id are stored by Curviate and read back on GET; a PATCH carrying only those makes no LinkedIn call. */
+            /** @description The updated account: the object GET /v1/accounts/{account_id} returns, without quotas and event_log (read those on GET). After a location change, connection_location is re-read from LinkedIn's side, so it shows where the account really connects from now. metadata and external_id are stored by Curviate; a PATCH carrying only those makes no LinkedIn call. */
             200: {
                 headers: {
                     "RateLimit-Policy": components["headers"]["RateLimit-Policy"];
@@ -28397,11 +29610,55 @@ interface operations {
                          */
                         object?: "account";
                         account_id?: string;
+                        /** @enum {string} */
+                        status?: "active" | "reconnect_needed" | "restricted" | "connecting" | "disconnected";
+                        auth_method?: string;
+                        full_name?: string | null;
+                        headline?: string | null;
+                        /** @description ISO-8601 UTC connection timestamp. */
+                        connected_at?: string | null;
+                        /** @description ISO-8601 UTC time the account state was last checked. */
+                        last_checked_at?: string;
+                        /** @description The seat this account occupies (null for an admin seatless account). */
+                        seat_id?: string | null;
+                        /** @description The connection scope this account was last connected with (e.g. ["classic","company","sales_navigator","recruiter"]). A connect asks for every product and LinkedIn activates the ones the account actually has, so this is what was ASKED for, narrowed only by an explicit linkedin_premium on that connect. A linkedin_premium narrowing is not remembered between connects, so this shows what the LAST connect asked for and a reconnect that omits the field widens it again. Null for accounts connected before this was recorded; not attachment truth for Company Pages. */
+                        requested_products?: ("classic" | "company" | "sales_navigator" | "recruiter")[] | null;
+                        /** @description Your own id for this account's end user, as set on connect or PATCH. Null when none. Not unique. */
+                        external_id?: string | null;
+                        /** @description Your own flat string map for this account, as last set by PATCH. Null when none. */
+                        metadata?: {
+                            [key: string]: string;
+                        } | null;
+                        /** @description Where LinkedIn sees this account connecting from. country: the configured country (ISO 3166-1 alpha-2), the one the account is set to use. current_country: the country of the connection in use right now; it differs from country only after a fallback, which can happen only when strict is false. mode: auto (a managed connection in country) or custom (your own proxy). strict: true when the account never connects from another country, null when unknown. Each field is null until known; an account connected through ip or your own proxy may show null until the next background refresh. Change it with PATCH /v1/accounts/{account_id} (country), or by reconnecting with country. */
+                        connection_location?: {
+                            /** @description Configured country (ISO 3166-1 alpha-2). */
+                            country?: string | null;
+                            /** @description Country of the connection in use right now. */
+                            current_country?: string | null;
+                            /**
+                             * @description auto: managed connection. custom: your own proxy.
+                             * @enum {string|null}
+                             */
+                            mode?: "auto" | "custom" | null;
+                            /** @description true: never connects from another country. */
+                            strict?: boolean | null;
+                        };
+                        /** @description ISO-8601 UTC creation timestamp of the underlying LinkedIn account, distinct from connected_at. Null until the first background enrichment lands. */
+                        substrate_created_at?: string | null;
+                        /** @description Platform conditions this LinkedIn account is currently in, additive to `status` and independent of it. `recruiter_session_evicted`: the account is signed in somewhere else and LinkedIn allows one session at a time for it, so a person has to close the other session; reconnecting will not help. `commercial_use_limited`: LinkedIn's commercial-use limit has tripped, so people search returns only a handful of results per query. It is a paywall, not a penalty, and nothing else about the account is affected. `profile_view_limited`: profile views outside this account's own network are being blocked; first-degree views still work. The two limits are detected from their symptom: LinkedIn publishes no threshold for either, exposes no counter, and lifts neither on request, so no number is reported. `commercial_use_limited` is a present-tense reading and a genuinely narrow search can also produce the shape it looks for, so treat it as a reason to check rather than a certainty; the next people search that returns a full page clears it. An account in none of these reports an empty array. */
+                        account_states?: ("recruiter_session_evicted" | "commercial_use_limited" | "profile_view_limited")[];
+                        /** @description The account's activity window, the hours in which Curviate reports or refuses live writes to LinkedIn. Reads and anything served from Curviate's own store are never affected, at any hour. Configure it on the account's safety policy. */
+                        activity_window?: {
+                            /** @description The IANA zone the window is read in, or null when none is set. */
+                            timezone?: string | null;
+                            /** @description True when no zone is set, which DISABLES the activity window. Curviate never guesses a zone: a guess eight hours wrong inverts the window, refusing every daytime write and permitting every nocturnal one. If you configured a window and it never fires, this is why. */
+                            timezone_unset?: boolean;
+                        };
                         safety_warning?: components["schemas"]["SafetyWarning"];
                     };
                 };
             };
-            /** @description Invalid request: a malformed proxy object, metadata over its limits (16 keys, key 40 chars, value 500), external_id outside 1-255 chars, or an unsupported field (country/ip). */
+            /** @description INVALID_REQUEST: a malformed proxy object; proxy together with country or allow_country_fallback; country on an account that uses your own proxy without proxy: null; allow_country_fallback alone on such an account; an unsupported country; ip (not changeable after connect; reconnect with ip instead); metadata over its limits (16 keys, key 40 chars, value 500); external_id outside 1-255 chars. CONNECTION_LOCATION_REQUIRED: proxy: null without country (clearing your own proxy alone would let the connection land anywhere). */
             400: {
                 headers: {
                     [name: string]: unknown;
@@ -28419,6 +29676,15 @@ interface operations {
                     "application/json": components["schemas"]["Error"];
                 };
             };
+            /** @description REAUTH_REQUIRED: the account is disconnected, so its location cannot change in place. Reconnect it (POST /v1/auth/intent with account_id) and pass country there. */
+            409: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
             /** @description Payload too large, the request body exceeds the size limit. */
             413: {
                 headers: {
@@ -28428,6 +29694,15 @@ interface operations {
                     "application/json": components["schemas"]["Error"];
                 };
             };
+            /** @description CONNECTION_LOCATION_UNAVAILABLE: no connection is free in that country right now, or the account did not end up there. When the change was applied but landed elsewhere, the body carries connection_location with where the account connects from now. Try a nearby country, or allow fallback. */
+            422: {
+                headers: {
+                    [name: string]: unknown;
+                };
+                content: {
+                    "application/json": components["schemas"]["Error"];
+                };
+            };
             /** @description Rate limited, slow down and retry after the hinted delay. */
             429: {
                 headers: {
@@ -28616,24 +29891,29 @@ interface operations {
                     external_id?: string;
                     /** @description Optional allow-list of premium products to ask for: sales_navigator, recruiter. Omit to ask for both; [] asks for none. Classic LinkedIn and company pages are always included. */
                     products?: ("sales_navigator" | "recruiter")[];
-                    /** @description Managed proxy location hint as an ISO 3166-1 alpha-2 country code (e.g. US, DE). */
-                    country?: string;
-                    /** @description IPv4 address used to infer the managed proxy location. */
+                    /**
+                     * @description Where LinkedIn sees this account connecting from: a supported ISO 3166-1 alpha-2 country code (e.g. US, DE; case-insensitive). Pick the country the account owner normally signs in from. A new connect needs exactly one of country, ip or proxy. Strict by default: the connect fails rather than use another country, unless allow_country_fallback is true.
+                     * @enum {string}
+                     */
+                    country?: "AE" | "AO" | "AR" | "AT" | "AU" | "BD" | "BE" | "BG" | "BR" | "CA" | "CH" | "CL" | "CN" | "CO" | "CY" | "CZ" | "DE" | "DK" | "EE" | "EG" | "ES" | "FI" | "FR" | "GB" | "GT" | "HK" | "ID" | "IE" | "IL" | "IN" | "IT" | "JP" | "KR" | "KZ" | "MA" | "MX" | "MY" | "NL" | "NO" | "PA" | "PH" | "PK" | "PL" | "PR" | "PT" | "RO" | "SA" | "SE" | "SG" | "TH" | "TN" | "TR" | "UA" | "US" | "VN" | "ZA";
+                    /** @description A public IPv4 address; its country becomes the connection location (strict by default). An alternative to country: send exactly one of country, ip or proxy on a new connect. */
                     ip?: string;
-                    /** @description Managed-proxy egress configuration for this account's outbound traffic. */
+                    /** @description Optional. false (the default with country or ip): only ever connect from that country; a connect fails when no connection is free there. true: a connection from another country may be used when none is free in the chosen one. Not accepted with proxy. */
+                    allow_country_fallback?: boolean;
+                    /** @description Your own proxy for this account's traffic. The proxy decides where LinkedIn sees the account connecting from, so country, ip and allow_country_fallback are not accepted with it. */
                     proxy?: {
                         /**
-                         * @description Proxy protocol. One of http, https, socks5.
+                         * @description Proxy protocol. One of http, https, socks5, socks4.
                          * @enum {string}
                          */
-                        protocol: "http" | "https" | "socks5";
+                        protocol: "http" | "https" | "socks5" | "socks4";
                         /** @description Proxy host or IP. */
                         host: string;
                         /** @description Proxy port (1-65535). */
                         port: number;
                         /** @description Proxy auth username (optional). */
                         username?: string;
-                        /** @description Proxy auth password (optional). Encrypted at rest, never logged or returned. */
+                        /** @description Proxy auth password (optional). Passed to the connection only: never stored, logged or returned. */
                         password?: string;
                     };
                     /** @description Exact browser User-Agent to pin for this account. REQUIRED for a cookie connect: send the User-Agent of the browser the li_at cookie was copied from. Optional for a credentials connect, where it helps an account that hits disconnection issues. */
@@ -28670,6 +29950,22 @@ interface operations {
                         status?: "active";
                         /** @description Your own id for this account's end user, as set on connect or PATCH. Null when none. Not unique. */
                         external_id?: string | null;
+                        /** @description Where LinkedIn sees this account connecting from. country: the configured country (ISO 3166-1 alpha-2), the one the account is set to use. current_country: the country of the connection in use right now; it differs from country only after a fallback, which can happen only when strict is false. mode: auto (a managed connection in country) or custom (your own proxy). strict: true when the account never connects from another country, null when unknown. Each field is null until known; an account connected through ip or your own proxy may show null until the next background refresh. Change it with PATCH /v1/accounts/{account_id} (country), or by reconnecting with country. */
+                        connection_location?: {
+                            /** @description Configured country (ISO 3166-1 alpha-2). */
+                            country?: string | null;
+                            /** @description Country of the connection in use right now. */
+                            current_country?: string | null;
+                            /**
+                             * @description auto: managed connection. custom: your own proxy.
+                             * @enum {string|null}
+                             */
+                            mode?: "auto" | "custom" | null;
+                            /** @description true: never connects from another country. */
+                            strict?: boolean | null;
+                            /** @description Present only when this connect landed on an account you already had and changed its configured country (to another one, to unknown with ip, or to your own proxy). It names the country before. */
+                            previous_country?: string;
+                        };
                         safety_warning?: components["schemas"]["SafetyWarning"];
                     };
                 };
@@ -28706,6 +30002,22 @@ interface operations {
                         external_id?: string | null;
                         /** @description Present and true only when this connect reactivated an account you had previously disconnected, instead of opening a brand-new one. Absent on a normal connect. The account keeps its original id, and its status reflects its real observed state, which may need a reconnect. */
                         recovered?: boolean;
+                        /** @description Where LinkedIn sees this account connecting from. country: the configured country (ISO 3166-1 alpha-2), the one the account is set to use. current_country: the country of the connection in use right now; it differs from country only after a fallback, which can happen only when strict is false. mode: auto (a managed connection in country) or custom (your own proxy). strict: true when the account never connects from another country, null when unknown. Each field is null until known; an account connected through ip or your own proxy may show null until the next background refresh. Change it with PATCH /v1/accounts/{account_id} (country), or by reconnecting with country. */
+                        connection_location?: {
+                            /** @description Configured country (ISO 3166-1 alpha-2). */
+                            country?: string | null;
+                            /** @description Country of the connection in use right now. */
+                            current_country?: string | null;
+                            /**
+                             * @description auto: managed connection. custom: your own proxy.
+                             * @enum {string|null}
+                             */
+                            mode?: "auto" | "custom" | null;
+                            /** @description true: never connects from another country. */
+                            strict?: boolean | null;
+                            /** @description Present only when this connect landed on an account you already had and changed its configured country (to another one, to unknown with ip, or to your own proxy). It names the country before. */
+                            previous_country?: string;
+                        };
                         safety_warning?: components["schemas"]["SafetyWarning"];
                     };
                 };
@@ -28755,7 +30067,7 @@ interface operations {
                     };
                 };
             };
-            /** @description INVALID_REQUEST. The most common causes: the auth block is at the top level instead of nested (send `credentials: { email, password }` or `cookie: { li_at }`, not bare `email`/`password`/`li_at`); `seat_id` is missing on a new connect; or a cookie connect has no top-level `user_agent`. SEAT_NOT_FOUND if the seat id is unknown or is not yours. */
+            /** @description CONNECTION_LOCATION_REQUIRED: a new connect names no location; send exactly one of `country` (a supported ISO code, e.g. `US`), `ip` (a public IPv4) or your own `proxy`. INVALID_REQUEST. The most common causes: two location sources at once (`ip` overrides `country`, `proxy` overrides both, so send one); an unsupported `country` (use `proxy` for a location we don't serve); a private or reserved `ip`; `allow_country_fallback` together with `proxy`; your own proxy rejected its credentials, could not be reached or timed out (the message names which); the auth block is at the top level instead of nested (send `credentials: { email, password }` or `cookie: { li_at }`, not bare `email`/`password`/`li_at`); `seat_id` is missing on a new connect; or a cookie connect has no top-level `user_agent`. SEAT_NOT_FOUND if the seat id is unknown or is not yours. */
             400: {
                 headers: {
                     [name: string]: unknown;
@@ -28791,7 +30103,7 @@ interface operations {
                     "application/json": components["schemas"]["Error"];
                 };
             };
-            /** @description This LinkedIn account is already linked (names your own account_id when your tenant owns it). */
+            /** @description ACCOUNT_ALREADY_LINKED: this LinkedIn account is already linked. It names your own account_id when your tenant owns it; otherwise no id is named, it is not one you can manage here, and retrying will not help. CONNECTION_IN_PROGRESS: another connection attempt for this identity is open; wait for it to finish or expire. */
             409: {
                 headers: {
                     [name: string]: unknown;
@@ -28809,7 +30121,7 @@ interface operations {
                     "application/json": components["schemas"]["Error"];
                 };
             };
-            /** @description The verification challenge cannot be resolved automatically (a dead-end challenge such as a CAPTCHA or a phone-number registration). For those two dead-ends the error body carries a machine-readable challenge_type (captcha | phone_register) so a client can render the right guidance; other unsupported challenges carry no challenge_type. */
+            /** @description CONNECTION_LOCATION_UNAVAILABLE: no connection is free in the country you chose right now (it is strict); try a nearby country, or send allow_country_fallback: true. Also returned when the connect re-attached an account you already had and its location could not be changed here (sent as ip): the body carries connection_location, and PATCH /v1/accounts/{account_id} with country moves it. CHECKPOINT_UNSUPPORTED: the verification challenge cannot be resolved automatically (a dead-end challenge such as a CAPTCHA or a phone-number registration). For those two dead-ends the error body carries a machine-readable challenge_type (captcha | phone_register) so a client can render the right guidance; other unsupported challenges carry no challenge_type. */
             422: {
                 headers: {
                     [name: string]: unknown;
@@ -28914,6 +30226,22 @@ interface operations {
                         external_id?: string | null;
                         /** @description Present and true only when this connect reactivated an account you had previously disconnected, instead of opening a brand-new one. Absent on a normal connect. The account keeps its original id, and its status reflects its real observed state, which may need a reconnect. */
                         recovered?: boolean;
+                        /** @description Where LinkedIn sees this account connecting from. country: the configured country (ISO 3166-1 alpha-2), the one the account is set to use. current_country: the country of the connection in use right now; it differs from country only after a fallback, which can happen only when strict is false. mode: auto (a managed connection in country) or custom (your own proxy). strict: true when the account never connects from another country, null when unknown. Each field is null until known; an account connected through ip or your own proxy may show null until the next background refresh. Change it with PATCH /v1/accounts/{account_id} (country), or by reconnecting with country. */
+                        connection_location?: {
+                            /** @description Configured country (ISO 3166-1 alpha-2). */
+                            country?: string | null;
+                            /** @description Country of the connection in use right now. */
+                            current_country?: string | null;
+                            /**
+                             * @description auto: managed connection. custom: your own proxy.
+                             * @enum {string|null}
+                             */
+                            mode?: "auto" | "custom" | null;
+                            /** @description true: never connects from another country. */
+                            strict?: boolean | null;
+                            /** @description Present only when this connect landed on an account you already had and changed its configured country (to another one, to unknown with ip, or to your own proxy). It names the country before. */
+                            previous_country?: string;
+                        };
                         safety_warning?: components["schemas"]["SafetyWarning"];
                     };
                 };
@@ -28997,7 +30325,7 @@ interface operations {
                     "application/json": components["schemas"]["Error"];
                 };
             };
-            /** @description The submitted code was incorrect, or the challenge type is unsupported. */
+            /** @description The submitted code was incorrect, or the challenge type is unsupported. CONNECTION_LOCATION_UNAVAILABLE: the connect completed onto an account you already had, and the location you sent could not be applied (no connection free in that country, or it was an ip); the account stays connected, the body carries its actual connection_location, and PATCH /v1/accounts/{account_id} with country moves it. */
             422: {
                 headers: {
                     [name: string]: unknown;
@@ -29293,6 +30621,22 @@ interface operations {
                         attached_seat_id?: string | null;
                         /** @description Your own id for this account's end user, as passed on connect. Present on status:"active". */
                         external_id?: string | null;
+                        /** @description Where LinkedIn sees this account connecting from. country: the configured country (ISO 3166-1 alpha-2), the one the account is set to use. current_country: the country of the connection in use right now; it differs from country only after a fallback, which can happen only when strict is false. mode: auto (a managed connection in country) or custom (your own proxy). strict: true when the account never connects from another country, null when unknown. Each field is null until known; an account connected through ip or your own proxy may show null until the next background refresh. Change it with PATCH /v1/accounts/{account_id} (country), or by reconnecting with country. Present on object:"account". */
+                        connection_location?: {
+                            /** @description Configured country (ISO 3166-1 alpha-2). */
+                            country?: string | null;
+                            /** @description Country of the connection in use right now. */
+                            current_country?: string | null;
+                            /**
+                             * @description auto: managed connection. custom: your own proxy.
+                             * @enum {string|null}
+                             */
+                            mode?: "auto" | "custom" | null;
+                            /** @description true: never connects from another country. */
+                            strict?: boolean | null;
+                            /** @description Present only when this connect landed on an account you already had and changed its configured country (to another one, to unknown with ip, or to your own proxy). It names the country before. */
+                            previous_country?: string;
+                        };
                         /** @description ISO-8601 expiry. Present on status:"pending" and status:"checkpoint_required". */
                         expires_at?: string;
                         /**
@@ -29347,7 +30691,7 @@ interface operations {
                     "application/json": components["schemas"]["Error"];
                 };
             };
-            /** @description The pending checkpoint is code-based, not mobile_app_approval, use submit instead. */
+            /** @description The pending checkpoint is code-based, not mobile_app_approval, use submit instead. CONNECTION_LOCATION_UNAVAILABLE: the approval completed onto an account you already had, and the location you sent could not be applied; the account stays connected, the body carries its actual connection_location, and PATCH /v1/accounts/{account_id} with country moves it. */
             422: {
                 headers: {
                     [name: string]: unknown;
@@ -30014,7 +31358,7 @@ interface operations {
                              * @description The event source this webhook subscribes to.
                              * @enum {string}
                              */
-                            source?: "messaging" | "user" | "account_status";
+                            source?: "messaging" | "user" | "account_status" | "post";
                             /** @description The URL that receives delivery POST requests. */
                             request_url?: string;
                             name?: string | null;
@@ -30176,6 +31520,30 @@ interface operations {
                     }[];
                     /** @description Account-status events to subscribe to (default: all 12 lifecycle events) */
                     events?: ("account.created" | "account.connected" | "account.synced" | "account.reconnected" | "account.reconnect_needed" | "account.restricted" | "account.creation_failed" | "account.disconnected" | "account.error" | "account.paused" | "account.connecting" | "account.permission_revoked" | "account.initial_sync.running" | "account.initial_sync.completed" | "account.initial_sync.failed")[];
+                } | {
+                    /** @constant */
+                    source: "post";
+                    /** @description HTTPS URL that receives webhook deliveries. Must be a publicly reachable host on the default https port; private, loopback and link-local addresses are rejected. */
+                    request_url: string;
+                    /** @description Human-readable name for this webhook (1-100 chars) */
+                    name?: string;
+                    /** @description Per-account targeting. Required and non-empty; each id must be an acc_-prefixed id owned by the tenant. */
+                    account_ids: string[];
+                    /**
+                     * @description A disabled webhook is created but delivers nothing
+                     * @default true
+                     */
+                    enabled?: boolean;
+                    /**
+                     * @description Custom headers added to each delivery POST. Names must be valid HTTP header names and values must be printable ASCII (no line breaks or control characters). Reserved names are rejected at registration; they include Content-Type, User-Agent, Host, any Curviate-* or Sec-* name, and the hop-by-hop headers. At most 10 headers, 1024 characters per value, 4096 bytes in total. Custom headers are not covered by the delivery signature, so treat them as a hint, not as proof of origin. Values are encrypted at rest and are never returned by a read. A read shows the header name plus a 8-character keyed fingerprint of the value, which carries no part of the value and no indication of its length. It is deterministic within your account, so a fingerprint confirms a rotation took effect and tells you whether two of your webhooks carry the same credential; fingerprints are not comparable across accounts. The header name is what identifies which credential is configured.
+                     * @default []
+                     */
+                    headers?: {
+                        key: string;
+                        value: string;
+                    }[];
+                    /** @description Post events to subscribe to (default: both post.published and post.publish_failed) */
+                    events?: ("post.published" | "post.publish_failed")[];
                 };
             };
         };
@@ -30200,7 +31568,7 @@ interface operations {
                          * @description The event source this webhook subscribes to.
                          * @enum {string}
                          */
-                        source?: "messaging" | "user" | "account_status";
+                        source?: "messaging" | "user" | "account_status" | "post";
                         /** @description The URL that receives delivery POST requests. */
                         request_url?: string;
                         /** @description Human-readable label. */
@@ -30218,7 +31586,7 @@ interface operations {
                         }[];
                         /** @description Canonical event names this webhook subscribes to. */
                         events?: string[];
-                        /** @description Field-remapping keys for the delivery payload (messaging and user sources only). */
+                        /** @description Field-remapping keys for the delivery payload (messaging and user sources only; post and account_status have none). */
                         data?: string[];
                         /**
                          * @description HMAC signing secret, 64 hexadecimal characters, returned exactly once at creation. Store it securely.
@@ -30320,7 +31688,7 @@ interface operations {
                         object?: "webhook_event_catalogue";
                         /** @description Event types grouped by source. */
                         sources?: {
-                            /** @description Event source group (messaging, user, account_status, recruiter, sales_nav). */
+                            /** @description Event source group (messaging, user, account_status, post, recruiter, sales_nav). */
                             source?: string;
                             events?: {
                                 /** @description Canonical event name. */
@@ -30478,7 +31846,7 @@ interface operations {
                          * @description The event source this webhook subscribes to (immutable).
                          * @enum {string}
                          */
-                        source?: "messaging" | "user" | "account_status";
+                        source?: "messaging" | "user" | "account_status" | "post";
                         /** @description The URL that receives delivery POST requests. */
                         request_url?: string;
                         /** @description Human-readable label. */
@@ -30496,7 +31864,7 @@ interface operations {
                         }[];
                         /** @description Canonical event names this webhook subscribes to. */
                         events?: string[];
-                        /** @description Field-remapping keys for the delivery payload (messaging and user sources only). */
+                        /** @description Field-remapping keys for the delivery payload (messaging and user sources only; post and account_status have none). */
                         data?: string[];
                         /** @description First 8 characters of the signing secret. The full secret is never returned on edit, it is preserved unchanged. */
                         secret_prefix?: string;
@@ -30674,7 +32042,7 @@ interface operations {
                          * @description The event source this webhook subscribes to (immutable).
                          * @enum {string}
                          */
-                        source?: "messaging" | "user" | "account_status";
+                        source?: "messaging" | "user" | "account_status" | "post";
                         /** @description The URL that receives delivery POST requests. */
                         request_url?: string;
                         /** @description Human-readable label. */
@@ -30692,7 +32060,7 @@ interface operations {
                         }[];
                         /** @description Canonical event names this webhook subscribes to. */
                         events?: string[];
-                        /** @description Field-remapping keys for the delivery payload (messaging and user sources only). */
+                        /** @description Field-remapping keys for the delivery payload (messaging and user sources only; post and account_status have none). */
                         data?: string[];
                         /** @description First 8 characters of the signing secret. The full secret is never returned on edit, it is preserved unchanged. */
                         secret_prefix?: string;
@@ -31797,7 +33165,7 @@ interface operations {
                     "application/json": components["schemas"]["Error"];
                 };
             };
-            /** @description The purchase failed after today's charge was taken; the charge was refunded in full and the seat count was confirmed unchanged, so no seats were added. Safe to retry. */
+            /** @description No seats were added. Branch on retry_likely_to_succeed. true: today's charge was refunded in full and the seat count was confirmed unchanged, so a retry is safe. false: whether today's charge went through could not be confirmed; a retry is a new purchase and could charge twice, so check your invoices first. */
             502: {
                 headers: {
                     [name: string]: unknown;
@@ -32081,7 +33449,7 @@ declare class AccountsResource {
      * const { items } = await curviate.accounts.listSeats();
      * const free = items.find((seat) => !seat.occupied);
      * if (!free) throw new Error("No seat is free to connect to right now (add a seat, or check billing).");
-     * await curviate.auth.intent({ seat_id: free.seat_id, auth_method: "cookie", cookie: { li_at }, user_agent });
+     * await curviate.auth.intent({ seat_id: free.seat_id, auth_method: "cookie", cookie: { li_at }, user_agent, country: "US" });
      */
     listSeats(): Promise<SeatList>;
     /**
@@ -32128,13 +33496,30 @@ declare class AccountsResource {
      * `metadata` is a flat string->string map (at most 16 keys, key 40 chars,
      * value 500) that **replaces** the stored map wholesale; `null` clears it.
      * Both are stored by Curviate, read back on `get`/`list`, and a PATCH
-     * carrying only them makes no LinkedIn call. `proxy` sets a custom egress
-     * proxy, or clears it (reverting to automatic proxy protection) when passed
-     * as `null`. The `proxy.password`, if given, is stored securely and never
-     * returned.
+     * carrying only them makes no LinkedIn call.
+     *
+     * `country` moves the account's connection location to that supported ISO
+     * country. LinkedIn sees a new IP there and may ask the owner to verify, so
+     * change it only when the current location is wrong. Strict unless
+     * `allow_country_fallback: true`; `allow_country_fallback` alone changes the
+     * strictness of the configured country. `proxy` sets your own proxy; `null`
+     * returns to a managed location and **requires** a `country` in the same
+     * call (else `CONNECTION_LOCATION_REQUIRED`), and an account on your own
+     * proxy can only take a `country` together with `proxy: null`. The
+     * `proxy.password`, if given, is never returned.
+     *
+     * Returns the account (as `get` returns it, without `quotas` and
+     * `event_log`). After a location change its `connection_location` is re-read,
+     * so it shows where the account really connects from now. A change that did
+     * not land where asked throws `CONNECTION_LOCATION_UNAVAILABLE`, whose
+     * `connectionLocation` carries the actual location.
      *
      * @example
      * await curviate.accounts.update("acc_123", { external_id: "usr_42", metadata: { plan: "pro" } });
+     *
+     * @example
+     * const account = await curviate.accounts.update("acc_123", { country: "DE" });
+     * console.log(account.connection_location?.country); // "DE"
      */
     update(accountId: string, body: AccountUpdateBody): Promise<AccountUpdateResult>;
     /**
@@ -32143,7 +33528,7 @@ declare class AccountsResource {
     disconnect(accountId: string): Promise<AccountDisconnectResult>;
     /**
      * Buy seats on the workspace's active subscription. Returns the new
-     * `seat_ids`; connect an account into one with `auth.intent({ seat_id })`.
+     * `seat_ids`; connect an account into one with `auth.intent({ seat_id, country, ... })`.
      *
      * Every call buys the `qty` it asks for, so a repeated call buys again.
      * The SDK never retries it for you. A
@@ -32204,8 +33589,53 @@ declare class AccountsResource {
  * a mid-flight connect/reconnect, never a path placeholder.
  */
 
-/** `POST /v1/auth/intent` request body. */
-type AuthIntentBody = paths["/v1/auth/intent"]["post"]["requestBody"]["content"]["application/json"];
+/** `POST /v1/auth/intent` request body, as the served document declares it (every location key optional). */
+type IntentWireBody = paths["/v1/auth/intent"]["post"]["requestBody"]["content"]["application/json"];
+/** A supported connection-location country (ISO 3166-1 alpha-2), the served enum. */
+type ConnectionCountry = NonNullable<IntentWireBody["country"]>;
+type LocationKeys = "country" | "ip" | "proxy" | "allow_country_fallback";
+/**
+ * Where LinkedIn sees the account connecting from: exactly one of `country`,
+ * `ip` or your own `proxy`. The served document cannot express "exactly one",
+ * so the SDK does: two sources, or `allow_country_fallback` with `proxy`, is a
+ * compile error here and a 400 on the wire.
+ */
+type ConnectionLocationSource = {
+    country: ConnectionCountry;
+    ip?: never;
+    proxy?: never;
+    allow_country_fallback?: boolean;
+} | {
+    ip: string;
+    country?: never;
+    proxy?: never;
+    allow_country_fallback?: boolean;
+} | {
+    proxy: NonNullable<IntentWireBody["proxy"]>;
+    country?: never;
+    ip?: never;
+    allow_country_fallback?: never;
+};
+/** No location keys: a reconnect that keeps the account's configured location. */
+type KeepLocation = {
+    country?: never;
+    ip?: never;
+    proxy?: never;
+    allow_country_fallback?: never;
+};
+/**
+ * `POST /v1/auth/intent` request body.
+ *
+ * A NEW connect (no `account_id`) must name a {@link ConnectionLocationSource};
+ * without one the API answers 400 `CONNECTION_LOCATION_REQUIRED`, and this type
+ * refuses it at compile time. A reconnect (`account_id` present) may omit it to
+ * keep the account's configured country and strictness, or send one to move it.
+ */
+type AuthIntentBody = Omit<IntentWireBody, LocationKeys | "account_id"> & (({
+    account_id?: undefined;
+} & ConnectionLocationSource) | ({
+    account_id: string;
+} & (ConnectionLocationSource | KeepLocation)));
 /** `POST /v1/auth/intent` 200 response body, an existing account re-authenticated in place. */
 type AuthIntentReconnected = paths["/v1/auth/intent"]["post"]["responses"]["200"]["content"]["application/json"];
 /** `POST /v1/auth/intent` 201 response body, a new account connected. */
@@ -32285,8 +33715,30 @@ declare class AuthResource {
      * LinkedIn account does not hold throws
      * `CurviateError(code: "LINKEDIN_FEATURE_NOT_SUBSCRIBED")` (403); the remedy
      * is to activate the subscription on LinkedIn or to point `linkedin_premium`
-     * at the premium the account really has. Pin a managed proxy with the
-     * optional `country`/`ip`, or supply `proxy` to override it entirely.
+     * at the premium the account really has.
+     *
+     * **Connection location.** A NEW connect must say where LinkedIn sees the
+     * account connecting from, with exactly one of: `country` (a supported ISO
+     * code such as `"US"`; pick the one the owner normally signs in from), `ip`
+     * (a public IPv4 whose country is used) or your own `proxy`. Without one the
+     * API throws `CurviateError(code: "CONNECTION_LOCATION_REQUIRED")`, and the
+     * {@link AuthIntentBody} type refuses it at compile time. `country` and `ip`
+     * are strict by default: the connect fails with
+     * `CONNECTION_LOCATION_UNAVAILABLE` rather than use another country, unless
+     * you send `allow_country_fallback: true`. A reconnect may omit the location
+     * to keep the account's configured one. The account's `connection_location`
+     * says where it connects from; when a connect re-attached an account you
+     * already had and moved it, `connection_location.previous_country` names
+     * where it was.
+     *
+     * @example
+     * const result = await curviate.auth.intent({
+     *   seat_id: "YOUR_SEAT_ID",
+     *   auth_method: "credentials",
+     *   credentials: { email: "YOUR_EMAIL", password: "YOUR_PASSWORD" },
+     *   country: "US",
+     * });
+     * console.log(result.account_id);
      */
     intent(body: AuthIntentBody): Promise<AuthIntentResult>;
     /**
@@ -32322,7 +33774,7 @@ declare class AuthResource {
      * @param body - optional `{ challenge }` for a `challenge_selection` checkpoint.
      *
      * @example
-     * const cp = await curviate.auth.intent({ seat_id, auth_method: "credentials", credentials });
+     * const cp = await curviate.auth.intent({ seat_id, auth_method: "credentials", credentials, country: "US" });
      * if (cp.object === "checkpoint" && cp.challenge_type === "challenge_selection") {
      *   const next = await curviate.auth.requestCheckpoint(cp.account_id!, { challenge: cp.challenges![0]!.id });
      * }
@@ -32858,15 +34310,15 @@ declare class PostsResource {
      * Get a single post. `GET /v1/{account_id}/posts/{post_id}`
      *
      * @param postId - the post's `id` as returned by {@link listUserPosts} or
-     *   {@link create}. A bare numeric id (`7332661864792854528`), a URN
-     *   (`urn:li:activity:N`, `urn:li:ugcPost:N`, `urn:li:share:N`), and a full
-     *   share URL (`https://www.linkedin.com/posts/...` or
+     *   {@link create}, or a post search result's `id`. A bare numeric id
+     *   (`7332661864792854528`), a URN (`urn:li:activity:N`, `urn:li:ugcPost:N`,
+     *   `urn:li:share:N`), and a full post URL (`https://www.linkedin.com/posts/...`
+     *   with an `activity-`, `ugcPost-` or `share-` slug, or
      *   `https://www.linkedin.com/feed/update/urn:li:activity:N`) all resolve to
      *   the same post. Pass the value as-is; it is percent-encoded into the path
      *   for you, so do not encode it yourself.
      *
-     *   {@link listComments} and the reaction operations are stricter: they take
-     *   the opaque `id` form only.
+     *   {@link listComments} and the reaction operations accept the same forms.
      */
     get(postId: string): Promise<PostDetail>;
     /** Delete a post (bodyless, 204). `DELETE /v1/{account_id}/posts/{post_id}` */
@@ -34334,13 +35786,149 @@ declare class WebhooksResource {
     delete(id: string): Promise<WebhookDeleteResult>;
 }
 
+/**
+ * Drafts resource: 7 methods (root-scoped).
+ *
+ * A Draft is a stored, editable, unpublished post. Give it an account and a
+ * `scheduled_at` and Curviate publishes it for you at that time. Scheduling
+ * never changes the id, so one Draft is one object from first save to publish.
+ *
+ * Root-scoped like `webhooks`: a Draft's account is optional, so there is no
+ * `account_id` path segment. `account_id` is a field of the Draft.
+ *
+ * `POST /v1/{account_id}/posts` (`posts.create`) publishes immediately and does
+ * not schedule. To schedule, create a Draft with `scheduled_at`.
+ *
+ * `delete` resolves with nothing (the API answers 204). `list` returns Drafts
+ * and, with `status: ["published"]`, publish records (never Drafts).
+ */
+
+type DraftCreateBody = paths["/v1/drafts"]["post"]["requestBody"]["content"]["application/json"];
+type DraftCreateResult = paths["/v1/drafts"]["post"]["responses"]["201"]["content"]["application/json"];
+type DraftListParams = NonNullable<paths["/v1/drafts"]["get"]["parameters"]["query"]>;
+type DraftListResult = paths["/v1/drafts"]["get"]["responses"]["200"]["content"]["application/json"];
+type DraftGetResult = paths["/v1/drafts/{id}"]["get"]["responses"]["200"]["content"]["application/json"];
+type DraftUpdateBody = paths["/v1/drafts/{id}"]["patch"]["requestBody"]["content"]["application/json"];
+type DraftUpdateResult = paths["/v1/drafts/{id}"]["patch"]["responses"]["200"]["content"]["application/json"];
+/** Delete-draft resolves with nothing: the API answers 204 with no body. */
+type DraftDeleteResult = void;
+type DraftPublishResult = paths["/v1/drafts/{id}/publish"]["post"]["responses"]["201"]["content"]["application/json"];
+/** The file types the upload route accepts as the raw body. */
+type DraftAttachmentContentType = keyof NonNullable<paths["/v1/drafts/{id}/attachments"]["post"]["requestBody"]>["content"];
+type DraftUploadResult = paths["/v1/drafts/{id}/attachments"]["post"]["responses"]["201"]["content"]["application/json"];
+/** Options for {@link DraftsResource.uploadAttachment}. */
+interface DraftUploadOptions {
+    /** The file's name, kept with the attachment. 1 to 255 characters. */
+    filename: string;
+    /**
+     * The file's type. Optional when `data` is a `Blob`/`File` that carries one.
+     * Anything outside {@link DraftAttachmentContentType} is refused with
+     * `415 UNSUPPORTED_MEDIA_TYPE`.
+     */
+    contentType?: DraftAttachmentContentType;
+}
+declare class DraftsResource {
+    protected readonly ctx: RequestContext;
+    constructor(ctx: RequestContext);
+    /**
+     * Store a Draft. Every field is optional, `account_id` and `text` included.
+     * `POST /v1/drafts`
+     *
+     * With `scheduled_at` (ISO 8601 with offset, between 5 minutes and 365 days
+     * ahead) the Draft is scheduled in the same call and needs an account and
+     * publishable text. Up to 50 Drafts and 2 GiB of media per account, and per
+     * no-account. A retry creates a second Draft.
+     *
+     * @example
+     * const draft = await curviate.drafts.create({
+     *   account_id: "acc_01J8Z3K9P0Q1R2S3T4V5W6X7Y8",
+     *   text: "Three things we learned shipping our first agent integration.",
+     *   scheduled_at: "2026-10-12T09:00:00+02:00",
+     * });
+     * // draft.status === "scheduled"
+     */
+    create(body?: DraftCreateBody): Promise<DraftCreateResult>;
+    /**
+     * List Drafts, cursor-paginated. `GET /v1/drafts`
+     *
+     * `status` defaults to `["draft", "scheduled", "failed"]`; add `"published"`
+     * to include publish records (`object: "publish_record"`, never Drafts).
+     * `account_id` is an `acc_` id or `"none"`. `from`/`to` are a half-open
+     * `[from, to)` range on each item's own date.
+     *
+     * @example
+     * const page = await curviate.drafts.list({ status: ["scheduled"], order: "asc" });
+     */
+    list(params?: DraftListParams): Promise<DraftListResult>;
+    /**
+     * Return one Draft, with a fresh signed link (valid 1 hour) per attachment.
+     * `GET /v1/drafts/{id}`
+     *
+     * @example
+     * const draft = await curviate.drafts.get("drf_01J8Z3K9P0Q1R2S3T4V5W6X7Y8");
+     */
+    get(id: string): Promise<DraftGetResult>;
+    /**
+     * Partial update: an omitted field is left as is, `null` clears it.
+     * `PATCH /v1/drafts/{id}`
+     *
+     * `attachments` replaces the whole list (`{ id }` keeps a file, a base64
+     * object adds one, anything left out is deleted). `scheduled_at` schedules,
+     * reschedules or, with `null`, unschedules. Editing a `failed` Draft clears
+     * its `failure`. A Draft being published answers `409 DRAFT_PUBLISHING`.
+     *
+     * @example
+     * await curviate.drafts.update(id, { scheduled_at: null }); // unschedule
+     */
+    update(id: string, body: DraftUpdateBody): Promise<DraftUpdateResult>;
+    /**
+     * Delete the Draft and its stored media (bodyless, 204).
+     * `DELETE /v1/drafts/{id}`
+     *
+     * @example
+     * await curviate.drafts.delete(id);
+     */
+    delete(id: string): Promise<DraftDeleteResult>;
+    /**
+     * Publish the Draft now, under the same rules and safety limits as
+     * `posts.create`. `POST /v1/drafts/{id}/publish`
+     *
+     * Success deletes the Draft and its media, writes a publish record and
+     * returns `{ object: "post_created", id }`; no webhook is sent. A known
+     * failure leaves the Draft unchanged. A `504` or `502` whose message says
+     * the outcome is unknown means the post may be live: check the account's
+     * posts before retrying.
+     *
+     * @example
+     * const { id: postId } = await curviate.drafts.publish(draftId);
+     */
+    publish(id: string): Promise<DraftPublishResult>;
+    /**
+     * Add one file to the Draft as the raw request body, for media too large to
+     * send inline: an MP4 video or a PDF, each up to 50 MiB. An image is capped at 5 MiB on
+     * every route. One file per call.
+     * `POST /v1/drafts/{id}/attachments?filename=...`
+     *
+     * Small files (up to 5 MiB) can instead ride inline in `create` / `update`
+     * as base64. Resolves with the Draft, the new attachment last.
+     *
+     * @example
+     * const bytes = await readFile("clip.mp4");
+     * const draft = await curviate.drafts.uploadAttachment(id, bytes, {
+     *   filename: "clip.mp4",
+     *   contentType: "video/mp4",
+     * });
+     */
+    uploadAttachment(id: string, data: Blob | ArrayBuffer | Uint8Array, options: DraftUploadOptions): Promise<DraftUploadResult>;
+}
+
 /**
  * Resource namespace assembly.
  *
  * The surface is split cleanly in two, with no overlap:
- * - **Root-scoped** (`accounts`, `auth`, `webhooks`) hang off the root client
- *   only. Connected-account management, connect/reconnect, and webhook
- *   registration are tenant-wide concerns, not per-account ones; they carry no
+ * - **Root-scoped** (`accounts`, `auth`, `webhooks`, `drafts`) hang off the root client
+ *   only. Connected-account management, connect/reconnect, webhook
+ *   registration and Drafts (a Draft's account is optional) are tenant-wide concerns, not per-account ones; they carry no
  *   `account_id` path segment.
  * - **Account-scoped** (everything else) hang off `curviate.account(id)` only.
  *   Every one of their paths leads with the fixed `account_id` segment, so they
@@ -34370,13 +35958,14 @@ interface ResourceNamespaces {
     jobs: JobsResource;
     companies: CompaniesResource;
     webhooks: WebhooksResource;
+    drafts: DraftsResource;
 }
 /**
- * The account-scoped accessor surface, every namespace except the three
- * root-only ones (`accounts`, `auth`, `webhooks`). The fixed `account_id` is
+ * The account-scoped accessor surface, every namespace except the four
+ * root-only ones (`accounts`, `auth`, `webhooks`, `drafts`). The fixed `account_id` is
  * injected by the bound context as the leading path segment.
  */
-type AccountScopedNamespaces = Omit<ResourceNamespaces, "accounts" | "auth" | "webhooks">;
+type AccountScopedNamespaces = Omit<ResourceNamespaces, "accounts" | "auth" | "webhooks" | "drafts">;
 
 /**
  * The Curviate client.
@@ -34397,6 +35986,7 @@ declare class Curviate {
     readonly accounts: AccountsResource;
     readonly auth: AuthResource;
     readonly webhooks: WebhooksResource;
+    readonly drafts: DraftsResource;
     constructor(config: CurviateConfig);
     /**
      * Return an account-scoped accessor that fixes `account_id` on every call,
@@ -34500,7 +36090,7 @@ declare class Curviate {
  * A code the API NEVER emitted is a different case and goes immediately, since
  * no deployment can be sending it: `RATE_LIMITED` went that way in 0.30.0.
  */
-declare const ERROR_CODES: readonly ["UNAUTHORIZED", "INVALID_REQUEST", "UNSUPPORTED_MEDIA_TYPE", "PAYLOAD_TOO_LARGE", "ACCOUNT_NOT_FOUND", "ACCOUNT_RESTRICTED", "ACCOUNT_ALREADY_LINKED", "RESOURCE_NOT_FOUND", "NOT_STORED", "RESOURCE_ACCESS_RESTRICTED", "FILTER_CANDIDATES_REQUIRED", "NO_ACTIVE_SEAT", "LINKEDIN_FEATURE_NOT_SUBSCRIBED", "BETA_NOT_ENABLED", "RATE_LIMIT_ACCOUNT", "RATE_LIMIT_TENANT", "PLATFORM_RATE_LIMIT", "BUDGET_EXHAUSTED", "PLATFORM_ERROR", "PLATFORM_NOT_IMPLEMENTED", "LINKEDIN_OPERATION_NOT_SUPPORTED", "CHECKPOINT_NOT_FOUND", "CHECKPOINT_EXPIRED", "CHECKPOINT_INVALID_CODE", "CHECKPOINT_MAX_ATTEMPTS", "CHECKPOINT_ALREADY_RESOLVED", "CHECKPOINT_UNSUPPORTED", "CONNECTION_IN_PROGRESS", "REAUTH_REQUIRED", "LINKEDIN_AUTH_FAILED", "LINKEDIN_SESSION_EVICTED", "LINKEDIN_RATE_LIMITED", "LINKEDIN_COOKIE_INVALID", "LINKEDIN_SERVICE_UNAVAILABLE", "MESSAGE_WINDOW_EXPIRED", "RECIPIENT_UNREACHABLE", "CONNECTION_REQUEST_CONFLICT", "PAYMENT_REQUIRED", "PAYMENT_FAILED", "SUBSCRIPTION_BUSY", "SUBSCRIPTION_NOT_FOUND", "SEAT_NOT_FOUND", "SEAT_CANCELLED", "NOT_FOUND", "REACTION_NOT_FOUND", "SUBSTRATE_LINK_FAILED", "SUBSTRATE_CAP_REACHED", "BILLING_CHECKOUT_FAILED", "BILLING_PORTAL_UNAVAILABLE", "ACCOUNT_DISPUTED", "ACCOUNT_LINKING_DISABLED", "PERIOD_LOCKED", "SEAT_NOT_EMPTY", "SEAT_PROVISIONAL", "SUBSCRIPTION_ALREADY_EXISTS", "ALREADY_CANCELLED", "CANCELLATION_ALREADY_EFFECTIVE", "INVALID_CANCELLATION_SOURCE", "TRIAL_EXPIRED", "TRIAL_SEAT_LIMIT", "TRIAL_ACTIVE_SEAT_LIMIT", "TRIAL_IDENTITY_ALREADY_USED", "TRIAL_IDENTITY_UNRESOLVED", "ADMIN_BYPASS", "STRIPE_DRIFT_DETECTED", "INTERNAL"];
+declare const ERROR_CODES: readonly ["UNAUTHORIZED", "INVALID_REQUEST", "UNSUPPORTED_MEDIA_TYPE", "PAYLOAD_TOO_LARGE", "ACCOUNT_NOT_FOUND", "ACCOUNT_RESTRICTED", "ACCOUNT_ALREADY_LINKED", "RESOURCE_NOT_FOUND", "NOT_STORED", "RESOURCE_ACCESS_RESTRICTED", "FILTER_CANDIDATES_REQUIRED", "NO_ACTIVE_SEAT", "LINKEDIN_FEATURE_NOT_SUBSCRIBED", "BETA_NOT_ENABLED", "RATE_LIMIT_ACCOUNT", "RATE_LIMIT_TENANT", "PLATFORM_RATE_LIMIT", "BUDGET_EXHAUSTED", "PLATFORM_ERROR", "PLATFORM_NOT_IMPLEMENTED", "LINKEDIN_OPERATION_NOT_SUPPORTED", "CHECKPOINT_NOT_FOUND", "CHECKPOINT_EXPIRED", "CHECKPOINT_INVALID_CODE", "CHECKPOINT_MAX_ATTEMPTS", "CHECKPOINT_ALREADY_RESOLVED", "CHECKPOINT_UNSUPPORTED", "CONNECTION_IN_PROGRESS", "CONNECTION_LOCATION_REQUIRED", "CONNECTION_LOCATION_UNAVAILABLE", "REAUTH_REQUIRED", "LINKEDIN_AUTH_FAILED", "LINKEDIN_SESSION_EVICTED", "LINKEDIN_RATE_LIMITED", "LINKEDIN_COOKIE_INVALID", "LINKEDIN_SERVICE_UNAVAILABLE", "MESSAGE_WINDOW_EXPIRED", "RECIPIENT_UNREACHABLE", "CONNECTION_REQUEST_CONFLICT", "PAYMENT_REQUIRED", "PAYMENT_FAILED", "SUBSCRIPTION_BUSY", "SUBSCRIPTION_NOT_FOUND", "SEAT_NOT_FOUND", "SEAT_CANCELLED", "NOT_FOUND", "REACTION_NOT_FOUND", "SUBSTRATE_LINK_FAILED", "SUBSTRATE_CAP_REACHED", "BILLING_CHECKOUT_FAILED", "BILLING_PORTAL_UNAVAILABLE", "ACCOUNT_DISPUTED", "ACCOUNT_LINKING_DISABLED", "PERIOD_LOCKED", "SEAT_NOT_EMPTY", "SEAT_PROVISIONAL", "SUBSCRIPTION_ALREADY_EXISTS", "ALREADY_CANCELLED", "CANCELLATION_ALREADY_EFFECTIVE", "INVALID_CANCELLATION_SOURCE", "TRIAL_EXPIRED", "TRIAL_SEAT_LIMIT", "TRIAL_ACTIVE_SEAT_LIMIT", "TRIAL_IDENTITY_ALREADY_USED", "TRIAL_IDENTITY_UNRESOLVED", "ADMIN_BYPASS", "STRIPE_DRIFT_DETECTED", "DRAFT_LIMIT_REACHED", "MEDIA_QUOTA_EXCEEDED", "ACCOUNT_REQUIRED", "DRAFT_NOT_PUBLISHABLE", "SCHEDULE_CONFLICT", "DRAFT_PUBLISHING", "INTERNAL"];
 /**
  * The complete set of error codes observable by API callers.
  *
@@ -34508,6 +36098,20 @@ declare const ERROR_CODES: readonly ["UNAUTHORIZED", "INVALID_REQUEST", "UNSUPPO
  * `switch (error.code)` without fear of unknown codes.
  */
 type ErrorCode = (typeof ERROR_CODES)[number];
+/**
+ * Where LinkedIn sees an account connecting from. Wire field
+ * `connection_location`; the same shape rides every account read.
+ * `country` is the configured country, `current_country` the one in use now
+ * (they differ only after a fallback), `mode` `auto` (managed) or `custom`
+ * (your own proxy), `strict` true when it never connects from another
+ * country. Each is `null` until known.
+ */
+interface ConnectionLocation {
+    country?: string | null;
+    current_country?: string | null;
+    mode?: "auto" | "custom" | null;
+    strict?: boolean | null;
+}
 /** Structured retry guidance attached to retryable errors. */
 interface RetryHint {
     kind: "delay" | "backoff" | "never";
@@ -34610,6 +36214,12 @@ interface CurviateErrorInit {
      * moving an account to `enforce` is not a breaking change.
      */
     blocked?: boolean;
+    /**
+     * Where the account connects from now, on a `CONNECTION_LOCATION_UNAVAILABLE`
+     * that followed an applied change (re-read after it). Wire field
+     * `connection_location`. Absent when nothing was changed.
+     */
+    connectionLocation?: ConnectionLocation;
 }
 /** Plain-object shape produced by {@link CurviateError.toJSON}. */
 interface CurviateErrorJSON {
@@ -34627,6 +36237,7 @@ interface CurviateErrorJSON {
     safetyHint?: SafetyHint;
     safetyReason?: SafetyReason;
     blocked?: boolean;
+    connectionLocation?: ConnectionLocation;
 }
 /**
  * The single thrown type for all Curviate API errors.
@@ -34660,6 +36271,8 @@ declare class CurviateError extends Error {
     readonly safetyReason: SafetyReason | undefined;
     /** Whether the action was refused. See {@link CurviateErrorInit.blocked}. */
     readonly blocked: boolean | undefined;
+    /** Where the account connects from now. See {@link CurviateErrorInit.connectionLocation}. */
+    readonly connectionLocation: ConnectionLocation | undefined;
     constructor(init: CurviateErrorInit);
     /**
      * Explicit, credential-safe serialization. Only the documented structured
@@ -34776,6 +36389,31 @@ interface AccountPayload extends EventPayloadBase {
      */
     external_id?: string | null;
 }
+/**
+ * Payload of `post.published`: a scheduled Draft went out. Carries ids and
+ * times only, never the post text or media.
+ */
+interface PostPublishedPayload extends EventPayloadBase {
+    draft_id: string;
+    /** The published post's id; `null` when none was returned. */
+    post_id: string | null;
+    scheduled_at: string;
+    published_at: string;
+    /** Present when a warn-posture safety limit was breached by this publish. */
+    safety_warning?: unknown;
+}
+/**
+ * Payload of `post.publish_failed`: a scheduled Draft could not be published.
+ * `failure_code` `outcome_unknown` means the post may be live: check the
+ * account's posts before retrying. Never carries the post text or media.
+ */
+interface PostPublishFailedPayload extends EventPayloadBase {
+    draft_id: string;
+    /** The time that failed (the Draft's own `scheduled_at` is cleared on failure). */
+    scheduled_at: string;
+    failure_code: string;
+    failure_message: string;
+}
 /**
  * Delivery metadata that accompanies every Curviate webhook event.
  *
@@ -34909,6 +36547,12 @@ type CurviateEvent = CurviateEventEnvelope & ({
 } | {
     event: "account.initial_sync.failed";
     data: AccountPayload;
+} | {
+    event: "post.published";
+    data: PostPublishedPayload;
+} | {
+    event: "post.publish_failed";
+    data: PostPublishFailedPayload;
 });
 /**
  * Options for {@link constructEvent}.
@@ -34968,4 +36612,4 @@ interface ConstructEventOptions {
  */
 declare function constructEvent(rawBody: string | Buffer, signatureHeader: string, secret: string, opts?: ConstructEventOptions): Promise<CurviateEvent>;
 
-export { type AccountListPage, type AccountListParams, type AccountPayload, type AccountScopedNamespaces, type ConnectionPayload, type ConstructEventOptions, Curviate, type CurviateConfig, CurviateError, type CurviateErrorInit, type CurviateErrorJSON, type CurviateEvent, type CurviateEventEnvelope, ERROR_CODES, type ErrorCode, type EventPayloadBase, type MessagePayload, type ResolvedConfig, type ResourceNamespaces, type RetryHint, type SafetyHint, type SafetyReason, type SeatList, WebhookSignatureError, type components, constructEvent, isCurviateError, type operations, type paths };
+export { type AccountDetail, type AccountListPage, type AccountListParams, type AccountPayload, type AccountScopedNamespaces, type AccountUpdateBody, type AccountUpdateResult, type AuthIntentBody, type ConnectionCountry, type ConnectionLocation, type ConnectionLocationSource, type ConnectionPayload, type ConstructEventOptions, Curviate, type CurviateConfig, CurviateError, type CurviateErrorInit, type CurviateErrorJSON, type CurviateEvent, type CurviateEventEnvelope, type DraftAttachmentContentType, type DraftCreateBody, type DraftCreateResult, type DraftDeleteResult, type DraftGetResult, type DraftListParams, type DraftListResult, type DraftPublishResult, type DraftUpdateBody, type DraftUpdateResult, type DraftUploadOptions, type DraftUploadResult, ERROR_CODES, type ErrorCode, type EventPayloadBase, type MessagePayload, type PostPublishFailedPayload, type PostPublishedPayload, type ResolvedConfig, type ResourceNamespaces, type RetryHint, type SafetyHint, type SafetyReason, type SeatList, WebhookSignatureError, type components, constructEvent, isCurviateError, type operations, type paths };