@postrun/js 2.11.0 → 2.13.0

package/dist/{types.gen-CENLQ15A.d.cts → types.gen-KaByz17A.d.cts}

@@ -5471,6 +5471,82 @@ type PostsListResponses = {
                      * Per-variant alt text; falls back to the asset’s alt_text.
                      */
                     alt_text_override: string | null;
+                    /**
+                     * The full media asset (kind, content_type, source dimensions, per-platform renditions) — the same shape as GET /v1/media.
+                     */
+                    media: {
+                        id: string;
+                        object: 'media';
+                        profile_id: string;
+                        /**
+                         * The detected asset family (image/video/gif/document). We sniff it from the uploaded bytes. null only in the brief pre-detection window while status is `uploading`; non-null once probed.
+                         */
+                        kind: 'image' | 'video' | 'gif' | 'document' | null;
+                        /**
+                         * The detected MIME of the uploaded original (e.g. video/mp4), sniffed from the bytes. null only in the brief pre-detection window while status is `uploading`.
+                         */
+                        content_type: string | null;
+                        status: 'uploading' | 'processing' | 'ready' | 'failed';
+                        /**
+                         * In-pipeline progress: the current step (stage) and a 0–100 bar (percent). Read `status` for the outcome; `percent` can regress on a transient retry.
+                         */
+                        progress: {
+                            stage: 'queued' | 'analyzing' | 'transcoding' | 'done';
+                            percent: number;
+                        };
+                        raw: boolean;
+                        /**
+                         * Asset-wide failure (the original itself is unusable, so no platform can succeed); null otherwise.
+                         */
+                        error: {
+                            code: 'media_unprobeable' | 'media_format_indeterminate' | 'media_format_unsupported' | 'media_too_large' | 'media_aspect_ratio_unsupported' | 'media_resolution_too_low' | 'media_gif_unsupported' | 'media_format_recompressed' | 'media_resolution_downscaled' | 'video_container_unsupported' | 'video_codec_unsupported' | 'video_audio_codec_unsupported' | 'video_too_large' | 'video_too_small' | 'video_dimensions_unsupported' | 'video_dimensions_too_large' | 'video_fps_unsupported' | 'video_fps_too_low' | 'video_aspect_unsupported' | 'video_duration_too_short' | 'video_duration_exceeds_max' | 'video_transform_failed' | 'media_fetch_failed' | 'document_format_unsupported' | 'document_too_large' | 'document_too_many_pages' | 'media_unsupported';
+                            message: string;
+                            hint?: string;
+                            allowed?: Array<unknown | null>;
+                            got?: string;
+                            /**
+                             * A short, friendly end-user line for `code` (render verbatim). `message` stays developer-grade; this is the display string. Size/limit codes interpolate the human cap/size.
+                             */
+                            display_error: string;
+                        } | null;
+                        source: {
+                            /**
+                             * MIME of the original, e.g. image/heic.
+                             */
+                            format: string;
+                            bytes: number;
+                            width: number | null;
+                            height: number | null;
+                            duration_ms: number | null;
+                        } | null;
+                        alt_text: string | null;
+                        per_platform: {
+                            [key: string]: {
+                                status?: unknown;
+                                url?: unknown;
+                                width?: unknown;
+                                height?: unknown;
+                                bytes?: unknown;
+                                warnings?: unknown;
+                                errors?: unknown;
+                            };
+                        };
+                        external_id: string | null;
+                        /**
+                         * Customer-owned key/value context, returned on reads and filterable on list endpoints (exact match). Values are scalars: string (≤500 chars), number, or boolean. At most 50 keys; keys ≤40 chars; total serialized JSON must fit in 16 KiB. Arrays and nested objects are out of scope for v1 (kept out to keep the contract scalar + exact-match). Keep a key’s value type consistent across records — filtering matches type-exactly. Never derive auth/scopes from metadata.
+                         */
+                        metadata: {
+                            [key: string]: unknown;
+                        };
+                        /**
+                         * ISO-8601 creation time.
+                         */
+                        created_at: string;
+                        /**
+                         * ISO-8601 last-update time.
+                         */
+                        updated_at: string;
+                    };
                 }>;
             } | {
                 platform: 'linkedin';
@@ -5597,6 +5673,82 @@ type PostsListResponses = {
                      * Per-variant alt text; falls back to the asset’s alt_text.
                      */
                     alt_text_override: string | null;
+                    /**
+                     * The full media asset (kind, content_type, source dimensions, per-platform renditions) — the same shape as GET /v1/media.
+                     */
+                    media: {
+                        id: string;
+                        object: 'media';
+                        profile_id: string;
+                        /**
+                         * The detected asset family (image/video/gif/document). We sniff it from the uploaded bytes. null only in the brief pre-detection window while status is `uploading`; non-null once probed.
+                         */
+                        kind: 'image' | 'video' | 'gif' | 'document' | null;
+                        /**
+                         * The detected MIME of the uploaded original (e.g. video/mp4), sniffed from the bytes. null only in the brief pre-detection window while status is `uploading`.
+                         */
+                        content_type: string | null;
+                        status: 'uploading' | 'processing' | 'ready' | 'failed';
+                        /**
+                         * In-pipeline progress: the current step (stage) and a 0–100 bar (percent). Read `status` for the outcome; `percent` can regress on a transient retry.
+                         */
+                        progress: {
+                            stage: 'queued' | 'analyzing' | 'transcoding' | 'done';
+                            percent: number;
+                        };
+                        raw: boolean;
+                        /**
+                         * Asset-wide failure (the original itself is unusable, so no platform can succeed); null otherwise.
+                         */
+                        error: {
+                            code: 'media_unprobeable' | 'media_format_indeterminate' | 'media_format_unsupported' | 'media_too_large' | 'media_aspect_ratio_unsupported' | 'media_resolution_too_low' | 'media_gif_unsupported' | 'media_format_recompressed' | 'media_resolution_downscaled' | 'video_container_unsupported' | 'video_codec_unsupported' | 'video_audio_codec_unsupported' | 'video_too_large' | 'video_too_small' | 'video_dimensions_unsupported' | 'video_dimensions_too_large' | 'video_fps_unsupported' | 'video_fps_too_low' | 'video_aspect_unsupported' | 'video_duration_too_short' | 'video_duration_exceeds_max' | 'video_transform_failed' | 'media_fetch_failed' | 'document_format_unsupported' | 'document_too_large' | 'document_too_many_pages' | 'media_unsupported';
+                            message: string;
+                            hint?: string;
+                            allowed?: Array<unknown | null>;
+                            got?: string;
+                            /**
+                             * A short, friendly end-user line for `code` (render verbatim). `message` stays developer-grade; this is the display string. Size/limit codes interpolate the human cap/size.
+                             */
+                            display_error: string;
+                        } | null;
+                        source: {
+                            /**
+                             * MIME of the original, e.g. image/heic.
+                             */
+                            format: string;
+                            bytes: number;
+                            width: number | null;
+                            height: number | null;
+                            duration_ms: number | null;
+                        } | null;
+                        alt_text: string | null;
+                        per_platform: {
+                            [key: string]: {
+                                status?: unknown;
+                                url?: unknown;
+                                width?: unknown;
+                                height?: unknown;
+                                bytes?: unknown;
+                                warnings?: unknown;
+                                errors?: unknown;
+                            };
+                        };
+                        external_id: string | null;
+                        /**
+                         * Customer-owned key/value context, returned on reads and filterable on list endpoints (exact match). Values are scalars: string (≤500 chars), number, or boolean. At most 50 keys; keys ≤40 chars; total serialized JSON must fit in 16 KiB. Arrays and nested objects are out of scope for v1 (kept out to keep the contract scalar + exact-match). Keep a key’s value type consistent across records — filtering matches type-exactly. Never derive auth/scopes from metadata.
+                         */
+                        metadata: {
+                            [key: string]: unknown;
+                        };
+                        /**
+                         * ISO-8601 creation time.
+                         */
+                        created_at: string;
+                        /**
+                         * ISO-8601 last-update time.
+                         */
+                        updated_at: string;
+                    };
                 }>;
             } | {
                 platform: 'facebook_page';
@@ -5651,6 +5803,82 @@ type PostsListResponses = {
                      * Per-variant alt text; falls back to the asset’s alt_text.
                      */
                     alt_text_override: string | null;
+                    /**
+                     * The full media asset (kind, content_type, source dimensions, per-platform renditions) — the same shape as GET /v1/media.
+                     */
+                    media: {
+                        id: string;
+                        object: 'media';
+                        profile_id: string;
+                        /**
+                         * The detected asset family (image/video/gif/document). We sniff it from the uploaded bytes. null only in the brief pre-detection window while status is `uploading`; non-null once probed.
+                         */
+                        kind: 'image' | 'video' | 'gif' | 'document' | null;
+                        /**
+                         * The detected MIME of the uploaded original (e.g. video/mp4), sniffed from the bytes. null only in the brief pre-detection window while status is `uploading`.
+                         */
+                        content_type: string | null;
+                        status: 'uploading' | 'processing' | 'ready' | 'failed';
+                        /**
+                         * In-pipeline progress: the current step (stage) and a 0–100 bar (percent). Read `status` for the outcome; `percent` can regress on a transient retry.
+                         */
+                        progress: {
+                            stage: 'queued' | 'analyzing' | 'transcoding' | 'done';
+                            percent: number;
+                        };
+                        raw: boolean;
+                        /**
+                         * Asset-wide failure (the original itself is unusable, so no platform can succeed); null otherwise.
+                         */
+                        error: {
+                            code: 'media_unprobeable' | 'media_format_indeterminate' | 'media_format_unsupported' | 'media_too_large' | 'media_aspect_ratio_unsupported' | 'media_resolution_too_low' | 'media_gif_unsupported' | 'media_format_recompressed' | 'media_resolution_downscaled' | 'video_container_unsupported' | 'video_codec_unsupported' | 'video_audio_codec_unsupported' | 'video_too_large' | 'video_too_small' | 'video_dimensions_unsupported' | 'video_dimensions_too_large' | 'video_fps_unsupported' | 'video_fps_too_low' | 'video_aspect_unsupported' | 'video_duration_too_short' | 'video_duration_exceeds_max' | 'video_transform_failed' | 'media_fetch_failed' | 'document_format_unsupported' | 'document_too_large' | 'document_too_many_pages' | 'media_unsupported';
+                            message: string;
+                            hint?: string;
+                            allowed?: Array<unknown | null>;
+                            got?: string;
+                            /**
+                             * A short, friendly end-user line for `code` (render verbatim). `message` stays developer-grade; this is the display string. Size/limit codes interpolate the human cap/size.
+                             */
+                            display_error: string;
+                        } | null;
+                        source: {
+                            /**
+                             * MIME of the original, e.g. image/heic.
+                             */
+                            format: string;
+                            bytes: number;
+                            width: number | null;
+                            height: number | null;
+                            duration_ms: number | null;
+                        } | null;
+                        alt_text: string | null;
+                        per_platform: {
+                            [key: string]: {
+                                status?: unknown;
+                                url?: unknown;
+                                width?: unknown;
+                                height?: unknown;
+                                bytes?: unknown;
+                                warnings?: unknown;
+                                errors?: unknown;
+                            };
+                        };
+                        external_id: string | null;
+                        /**
+                         * Customer-owned key/value context, returned on reads and filterable on list endpoints (exact match). Values are scalars: string (≤500 chars), number, or boolean. At most 50 keys; keys ≤40 chars; total serialized JSON must fit in 16 KiB. Arrays and nested objects are out of scope for v1 (kept out to keep the contract scalar + exact-match). Keep a key’s value type consistent across records — filtering matches type-exactly. Never derive auth/scopes from metadata.
+                         */
+                        metadata: {
+                            [key: string]: unknown;
+                        };
+                        /**
+                         * ISO-8601 creation time.
+                         */
+                        created_at: string;
+                        /**
+                         * ISO-8601 last-update time.
+                         */
+                        updated_at: string;
+                    };
                 }>;
             } | {
                 platform: 'instagram';
@@ -5746,6 +5974,82 @@ type PostsListResponses = {
                      * Per-variant alt text; falls back to the asset’s alt_text.
                      */
                     alt_text_override: string | null;
+                    /**
+                     * The full media asset (kind, content_type, source dimensions, per-platform renditions) — the same shape as GET /v1/media.
+                     */
+                    media: {
+                        id: string;
+                        object: 'media';
+                        profile_id: string;
+                        /**
+                         * The detected asset family (image/video/gif/document). We sniff it from the uploaded bytes. null only in the brief pre-detection window while status is `uploading`; non-null once probed.
+                         */
+                        kind: 'image' | 'video' | 'gif' | 'document' | null;
+                        /**
+                         * The detected MIME of the uploaded original (e.g. video/mp4), sniffed from the bytes. null only in the brief pre-detection window while status is `uploading`.
+                         */
+                        content_type: string | null;
+                        status: 'uploading' | 'processing' | 'ready' | 'failed';
+                        /**
+                         * In-pipeline progress: the current step (stage) and a 0–100 bar (percent). Read `status` for the outcome; `percent` can regress on a transient retry.
+                         */
+                        progress: {
+                            stage: 'queued' | 'analyzing' | 'transcoding' | 'done';
+                            percent: number;
+                        };
+                        raw: boolean;
+                        /**
+                         * Asset-wide failure (the original itself is unusable, so no platform can succeed); null otherwise.
+                         */
+                        error: {
+                            code: 'media_unprobeable' | 'media_format_indeterminate' | 'media_format_unsupported' | 'media_too_large' | 'media_aspect_ratio_unsupported' | 'media_resolution_too_low' | 'media_gif_unsupported' | 'media_format_recompressed' | 'media_resolution_downscaled' | 'video_container_unsupported' | 'video_codec_unsupported' | 'video_audio_codec_unsupported' | 'video_too_large' | 'video_too_small' | 'video_dimensions_unsupported' | 'video_dimensions_too_large' | 'video_fps_unsupported' | 'video_fps_too_low' | 'video_aspect_unsupported' | 'video_duration_too_short' | 'video_duration_exceeds_max' | 'video_transform_failed' | 'media_fetch_failed' | 'document_format_unsupported' | 'document_too_large' | 'document_too_many_pages' | 'media_unsupported';
+                            message: string;
+                            hint?: string;
+                            allowed?: Array<unknown | null>;
+                            got?: string;
+                            /**
+                             * A short, friendly end-user line for `code` (render verbatim). `message` stays developer-grade; this is the display string. Size/limit codes interpolate the human cap/size.
+                             */
+                            display_error: string;
+                        } | null;
+                        source: {
+                            /**
+                             * MIME of the original, e.g. image/heic.
+                             */
+                            format: string;
+                            bytes: number;
+                            width: number | null;
+                            height: number | null;
+                            duration_ms: number | null;
+                        } | null;
+                        alt_text: string | null;
+                        per_platform: {
+                            [key: string]: {
+                                status?: unknown;
+                                url?: unknown;
+                                width?: unknown;
+                                height?: unknown;
+                                bytes?: unknown;
+                                warnings?: unknown;
+                                errors?: unknown;
+                            };
+                        };
+                        external_id: string | null;
+                        /**
+                         * Customer-owned key/value context, returned on reads and filterable on list endpoints (exact match). Values are scalars: string (≤500 chars), number, or boolean. At most 50 keys; keys ≤40 chars; total serialized JSON must fit in 16 KiB. Arrays and nested objects are out of scope for v1 (kept out to keep the contract scalar + exact-match). Keep a key’s value type consistent across records — filtering matches type-exactly. Never derive auth/scopes from metadata.
+                         */
+                        metadata: {
+                            [key: string]: unknown;
+                        };
+                        /**
+                         * ISO-8601 creation time.
+                         */
+                        created_at: string;
+                        /**
+                         * ISO-8601 last-update time.
+                         */
+                        updated_at: string;
+                    };
                 }>;
             } | {
                 platform: 'tiktok';
@@ -5836,6 +6140,82 @@ type PostsListResponses = {
                      * Per-variant alt text; falls back to the asset’s alt_text.
                      */
                     alt_text_override: string | null;
+                    /**
+                     * The full media asset (kind, content_type, source dimensions, per-platform renditions) — the same shape as GET /v1/media.
+                     */
+                    media: {
+                        id: string;
+                        object: 'media';
+                        profile_id: string;
+                        /**
+                         * The detected asset family (image/video/gif/document). We sniff it from the uploaded bytes. null only in the brief pre-detection window while status is `uploading`; non-null once probed.
+                         */
+                        kind: 'image' | 'video' | 'gif' | 'document' | null;
+                        /**
+                         * The detected MIME of the uploaded original (e.g. video/mp4), sniffed from the bytes. null only in the brief pre-detection window while status is `uploading`.
+                         */
+                        content_type: string | null;
+                        status: 'uploading' | 'processing' | 'ready' | 'failed';
+                        /**
+                         * In-pipeline progress: the current step (stage) and a 0–100 bar (percent). Read `status` for the outcome; `percent` can regress on a transient retry.
+                         */
+                        progress: {
+                            stage: 'queued' | 'analyzing' | 'transcoding' | 'done';
+                            percent: number;
+                        };
+                        raw: boolean;
+                        /**
+                         * Asset-wide failure (the original itself is unusable, so no platform can succeed); null otherwise.
+                         */
+                        error: {
+                            code: 'media_unprobeable' | 'media_format_indeterminate' | 'media_format_unsupported' | 'media_too_large' | 'media_aspect_ratio_unsupported' | 'media_resolution_too_low' | 'media_gif_unsupported' | 'media_format_recompressed' | 'media_resolution_downscaled' | 'video_container_unsupported' | 'video_codec_unsupported' | 'video_audio_codec_unsupported' | 'video_too_large' | 'video_too_small' | 'video_dimensions_unsupported' | 'video_dimensions_too_large' | 'video_fps_unsupported' | 'video_fps_too_low' | 'video_aspect_unsupported' | 'video_duration_too_short' | 'video_duration_exceeds_max' | 'video_transform_failed' | 'media_fetch_failed' | 'document_format_unsupported' | 'document_too_large' | 'document_too_many_pages' | 'media_unsupported';
+                            message: string;
+                            hint?: string;
+                            allowed?: Array<unknown | null>;
+                            got?: string;
+                            /**
+                             * A short, friendly end-user line for `code` (render verbatim). `message` stays developer-grade; this is the display string. Size/limit codes interpolate the human cap/size.
+                             */
+                            display_error: string;
+                        } | null;
+                        source: {
+                            /**
+                             * MIME of the original, e.g. image/heic.
+                             */
+                            format: string;
+                            bytes: number;
+                            width: number | null;
+                            height: number | null;
+                            duration_ms: number | null;
+                        } | null;
+                        alt_text: string | null;
+                        per_platform: {
+                            [key: string]: {
+                                status?: unknown;
+                                url?: unknown;
+                                width?: unknown;
+                                height?: unknown;
+                                bytes?: unknown;
+                                warnings?: unknown;
+                                errors?: unknown;
+                            };
+                        };
+                        external_id: string | null;
+                        /**
+                         * Customer-owned key/value context, returned on reads and filterable on list endpoints (exact match). Values are scalars: string (≤500 chars), number, or boolean. At most 50 keys; keys ≤40 chars; total serialized JSON must fit in 16 KiB. Arrays and nested objects are out of scope for v1 (kept out to keep the contract scalar + exact-match). Keep a key’s value type consistent across records — filtering matches type-exactly. Never derive auth/scopes from metadata.
+                         */
+                        metadata: {
+                            [key: string]: unknown;
+                        };
+                        /**
+                         * ISO-8601 creation time.
+                         */
+                        created_at: string;
+                        /**
+                         * ISO-8601 last-update time.
+                         */
+                        updated_at: string;
+                    };
                 }>;
             }>;
             /**
@@ -6664,6 +7044,99 @@ type PostsCreateResponses = {
                  * Per-variant alt text; falls back to the asset’s alt_text.
                  */
                 alt_text_override: string | null;
+                /**
+                 * The full media asset (kind, content_type, source dimensions, per-platform renditions) — the same shape as GET /v1/media.
+                 */
+                media: {
+                    id: string;
+                    object: 'media';
+                    profile_id: string;
+                    /**
+                     * The detected asset family (image/video/gif/document). We sniff it from the uploaded bytes. null only in the brief pre-detection window while status is `uploading`; non-null once probed.
+                     */
+                    kind: 'image' | 'video' | 'gif' | 'document' | null;
+                    /**
+                     * The detected MIME of the uploaded original (e.g. video/mp4), sniffed from the bytes. null only in the brief pre-detection window while status is `uploading`.
+                     */
+                    content_type: string | null;
+                    status: 'uploading' | 'processing' | 'ready' | 'failed';
+                    /**
+                     * In-pipeline progress: the current step (stage) and a 0–100 bar (percent). Read `status` for the outcome; `percent` can regress on a transient retry.
+                     */
+                    progress: {
+                        stage: 'queued' | 'analyzing' | 'transcoding' | 'done';
+                        percent: number;
+                    };
+                    raw: boolean;
+                    /**
+                     * Asset-wide failure (the original itself is unusable, so no platform can succeed); null otherwise.
+                     */
+                    error: {
+                        code: 'media_unprobeable' | 'media_format_indeterminate' | 'media_format_unsupported' | 'media_too_large' | 'media_aspect_ratio_unsupported' | 'media_resolution_too_low' | 'media_gif_unsupported' | 'media_format_recompressed' | 'media_resolution_downscaled' | 'video_container_unsupported' | 'video_codec_unsupported' | 'video_audio_codec_unsupported' | 'video_too_large' | 'video_too_small' | 'video_dimensions_unsupported' | 'video_dimensions_too_large' | 'video_fps_unsupported' | 'video_fps_too_low' | 'video_aspect_unsupported' | 'video_duration_too_short' | 'video_duration_exceeds_max' | 'video_transform_failed' | 'media_fetch_failed' | 'document_format_unsupported' | 'document_too_large' | 'document_too_many_pages' | 'media_unsupported';
+                        message: string;
+                        hint?: string;
+                        allowed?: Array<string>;
+                        got?: string;
+                        /**
+                         * A short, friendly end-user line for `code` (render verbatim). `message` stays developer-grade; this is the display string. Size/limit codes interpolate the human cap/size.
+                         */
+                        display_error: string;
+                    } | null;
+                    source: {
+                        /**
+                         * MIME of the original, e.g. image/heic.
+                         */
+                        format: string;
+                        bytes: number;
+                        width: number | null;
+                        height: number | null;
+                        duration_ms: number | null;
+                    } | null;
+                    alt_text: string | null;
+                    per_platform: {
+                        [key: string]: {
+                            status: 'processing' | 'ready' | 'failed';
+                            /**
+                             * Public URL of this platform’s rendition (null until ready).
+                             */
+                            url: string | null;
+                            width: number | null;
+                            height: number | null;
+                            bytes: number | null;
+                            warnings: Array<{
+                                code?: unknown;
+                                message?: unknown;
+                                hint?: unknown;
+                                allowed?: unknown;
+                                got?: unknown;
+                                display_error?: unknown;
+                            }>;
+                            errors: Array<{
+                                code?: unknown;
+                                message?: unknown;
+                                hint?: unknown;
+                                allowed?: unknown;
+                                got?: unknown;
+                                display_error?: unknown;
+                            }>;
+                        };
+                    };
+                    external_id: string | null;
+                    /**
+                     * Customer-owned key/value context, returned on reads and filterable on list endpoints (exact match). Values are scalars: string (≤500 chars), number, or boolean. At most 50 keys; keys ≤40 chars; total serialized JSON must fit in 16 KiB. Arrays and nested objects are out of scope for v1 (kept out to keep the contract scalar + exact-match). Keep a key’s value type consistent across records — filtering matches type-exactly. Never derive auth/scopes from metadata.
+                     */
+                    metadata: {
+                        [key: string]: string | number | boolean;
+                    };
+                    /**
+                     * ISO-8601 creation time.
+                     */
+                    created_at: string;
+                    /**
+                     * ISO-8601 last-update time.
+                     */
+                    updated_at: string;
+                };
             }>;
         } | {
             platform: 'linkedin';
@@ -6790,6 +7263,99 @@ type PostsCreateResponses = {
                  * Per-variant alt text; falls back to the asset’s alt_text.
                  */
                 alt_text_override: string | null;
+                /**
+                 * The full media asset (kind, content_type, source dimensions, per-platform renditions) — the same shape as GET /v1/media.
+                 */
+                media: {
+                    id: string;
+                    object: 'media';
+                    profile_id: string;
+                    /**
+                     * The detected asset family (image/video/gif/document). We sniff it from the uploaded bytes. null only in the brief pre-detection window while status is `uploading`; non-null once probed.
+                     */
+                    kind: 'image' | 'video' | 'gif' | 'document' | null;
+                    /**
+                     * The detected MIME of the uploaded original (e.g. video/mp4), sniffed from the bytes. null only in the brief pre-detection window while status is `uploading`.
+                     */
+                    content_type: string | null;
+                    status: 'uploading' | 'processing' | 'ready' | 'failed';
+                    /**
+                     * In-pipeline progress: the current step (stage) and a 0–100 bar (percent). Read `status` for the outcome; `percent` can regress on a transient retry.
+                     */
+                    progress: {
+                        stage: 'queued' | 'analyzing' | 'transcoding' | 'done';
+                        percent: number;
+                    };
+                    raw: boolean;
+                    /**
+                     * Asset-wide failure (the original itself is unusable, so no platform can succeed); null otherwise.
+                     */
+                    error: {
+                        code: 'media_unprobeable' | 'media_format_indeterminate' | 'media_format_unsupported' | 'media_too_large' | 'media_aspect_ratio_unsupported' | 'media_resolution_too_low' | 'media_gif_unsupported' | 'media_format_recompressed' | 'media_resolution_downscaled' | 'video_container_unsupported' | 'video_codec_unsupported' | 'video_audio_codec_unsupported' | 'video_too_large' | 'video_too_small' | 'video_dimensions_unsupported' | 'video_dimensions_too_large' | 'video_fps_unsupported' | 'video_fps_too_low' | 'video_aspect_unsupported' | 'video_duration_too_short' | 'video_duration_exceeds_max' | 'video_transform_failed' | 'media_fetch_failed' | 'document_format_unsupported' | 'document_too_large' | 'document_too_many_pages' | 'media_unsupported';
+                        message: string;
+                        hint?: string;
+                        allowed?: Array<string>;
+                        got?: string;
+                        /**
+                         * A short, friendly end-user line for `code` (render verbatim). `message` stays developer-grade; this is the display string. Size/limit codes interpolate the human cap/size.
+                         */
+                        display_error: string;
+                    } | null;
+                    source: {
+                        /**
+                         * MIME of the original, e.g. image/heic.
+                         */
+                        format: string;
+                        bytes: number;
+                        width: number | null;
+                        height: number | null;
+                        duration_ms: number | null;
+                    } | null;
+                    alt_text: string | null;
+                    per_platform: {
+                        [key: string]: {
+                            status: 'processing' | 'ready' | 'failed';
+                            /**
+                             * Public URL of this platform’s rendition (null until ready).
+                             */
+                            url: string | null;
+                            width: number | null;
+                            height: number | null;
+                            bytes: number | null;
+                            warnings: Array<{
+                                code?: unknown;
+                                message?: unknown;
+                                hint?: unknown;
+                                allowed?: unknown;
+                                got?: unknown;
+                                display_error?: unknown;
+                            }>;
+                            errors: Array<{
+                                code?: unknown;
+                                message?: unknown;
+                                hint?: unknown;
+                                allowed?: unknown;
+                                got?: unknown;
+                                display_error?: unknown;
+                            }>;
+                        };
+                    };
+                    external_id: string | null;
+                    /**
+                     * Customer-owned key/value context, returned on reads and filterable on list endpoints (exact match). Values are scalars: string (≤500 chars), number, or boolean. At most 50 keys; keys ≤40 chars; total serialized JSON must fit in 16 KiB. Arrays and nested objects are out of scope for v1 (kept out to keep the contract scalar + exact-match). Keep a key’s value type consistent across records — filtering matches type-exactly. Never derive auth/scopes from metadata.
+                     */
+                    metadata: {
+                        [key: string]: string | number | boolean;
+                    };
+                    /**
+                     * ISO-8601 creation time.
+                     */
+                    created_at: string;
+                    /**
+                     * ISO-8601 last-update time.
+                     */
+                    updated_at: string;
+                };
             }>;
         } | {
             platform: 'facebook_page';
@@ -6844,6 +7410,99 @@ type PostsCreateResponses = {
                  * Per-variant alt text; falls back to the asset’s alt_text.
                  */
                 alt_text_override: string | null;
+                /**
+                 * The full media asset (kind, content_type, source dimensions, per-platform renditions) — the same shape as GET /v1/media.
+                 */
+                media: {
+                    id: string;
+                    object: 'media';
+                    profile_id: string;
+                    /**
+                     * The detected asset family (image/video/gif/document). We sniff it from the uploaded bytes. null only in the brief pre-detection window while status is `uploading`; non-null once probed.
+                     */
+                    kind: 'image' | 'video' | 'gif' | 'document' | null;
+                    /**
+                     * The detected MIME of the uploaded original (e.g. video/mp4), sniffed from the bytes. null only in the brief pre-detection window while status is `uploading`.
+                     */
+                    content_type: string | null;
+                    status: 'uploading' | 'processing' | 'ready' | 'failed';
+                    /**
+                     * In-pipeline progress: the current step (stage) and a 0–100 bar (percent). Read `status` for the outcome; `percent` can regress on a transient retry.
+                     */
+                    progress: {
+                        stage: 'queued' | 'analyzing' | 'transcoding' | 'done';
+                        percent: number;
+                    };
+                    raw: boolean;
+                    /**
+                     * Asset-wide failure (the original itself is unusable, so no platform can succeed); null otherwise.
+                     */
+                    error: {
+                        code: 'media_unprobeable' | 'media_format_indeterminate' | 'media_format_unsupported' | 'media_too_large' | 'media_aspect_ratio_unsupported' | 'media_resolution_too_low' | 'media_gif_unsupported' | 'media_format_recompressed' | 'media_resolution_downscaled' | 'video_container_unsupported' | 'video_codec_unsupported' | 'video_audio_codec_unsupported' | 'video_too_large' | 'video_too_small' | 'video_dimensions_unsupported' | 'video_dimensions_too_large' | 'video_fps_unsupported' | 'video_fps_too_low' | 'video_aspect_unsupported' | 'video_duration_too_short' | 'video_duration_exceeds_max' | 'video_transform_failed' | 'media_fetch_failed' | 'document_format_unsupported' | 'document_too_large' | 'document_too_many_pages' | 'media_unsupported';
+                        message: string;
+                        hint?: string;
+                        allowed?: Array<string>;
+                        got?: string;
+                        /**
+                         * A short, friendly end-user line for `code` (render verbatim). `message` stays developer-grade; this is the display string. Size/limit codes interpolate the human cap/size.
+                         */
+                        display_error: string;
+                    } | null;
+                    source: {
+                        /**
+                         * MIME of the original, e.g. image/heic.
+                         */
+                        format: string;
+                        bytes: number;
+                        width: number | null;
+                        height: number | null;
+                        duration_ms: number | null;
+                    } | null;
+                    alt_text: string | null;
+                    per_platform: {
+                        [key: string]: {
+                            status: 'processing' | 'ready' | 'failed';
+                            /**
+                             * Public URL of this platform’s rendition (null until ready).
+                             */
+                            url: string | null;
+                            width: number | null;
+                            height: number | null;
+                            bytes: number | null;
+                            warnings: Array<{
+                                code?: unknown;
+                                message?: unknown;
+                                hint?: unknown;
+                                allowed?: unknown;
+                                got?: unknown;
+                                display_error?: unknown;
+                            }>;
+                            errors: Array<{
+                                code?: unknown;
+                                message?: unknown;
+                                hint?: unknown;
+                                allowed?: unknown;
+                                got?: unknown;
+                                display_error?: unknown;
+                            }>;
+                        };
+                    };
+                    external_id: string | null;
+                    /**
+                     * Customer-owned key/value context, returned on reads and filterable on list endpoints (exact match). Values are scalars: string (≤500 chars), number, or boolean. At most 50 keys; keys ≤40 chars; total serialized JSON must fit in 16 KiB. Arrays and nested objects are out of scope for v1 (kept out to keep the contract scalar + exact-match). Keep a key’s value type consistent across records — filtering matches type-exactly. Never derive auth/scopes from metadata.
+                     */
+                    metadata: {
+                        [key: string]: string | number | boolean;
+                    };
+                    /**
+                     * ISO-8601 creation time.
+                     */
+                    created_at: string;
+                    /**
+                     * ISO-8601 last-update time.
+                     */
+                    updated_at: string;
+                };
             }>;
         } | {
             platform: 'instagram';
@@ -6939,6 +7598,99 @@ type PostsCreateResponses = {
                  * Per-variant alt text; falls back to the asset’s alt_text.
                  */
                 alt_text_override: string | null;
+                /**
+                 * The full media asset (kind, content_type, source dimensions, per-platform renditions) — the same shape as GET /v1/media.
+                 */
+                media: {
+                    id: string;
+                    object: 'media';
+                    profile_id: string;
+                    /**
+                     * The detected asset family (image/video/gif/document). We sniff it from the uploaded bytes. null only in the brief pre-detection window while status is `uploading`; non-null once probed.
+                     */
+                    kind: 'image' | 'video' | 'gif' | 'document' | null;
+                    /**
+                     * The detected MIME of the uploaded original (e.g. video/mp4), sniffed from the bytes. null only in the brief pre-detection window while status is `uploading`.
+                     */
+                    content_type: string | null;
+                    status: 'uploading' | 'processing' | 'ready' | 'failed';
+                    /**
+                     * In-pipeline progress: the current step (stage) and a 0–100 bar (percent). Read `status` for the outcome; `percent` can regress on a transient retry.
+                     */
+                    progress: {
+                        stage: 'queued' | 'analyzing' | 'transcoding' | 'done';
+                        percent: number;
+                    };
+                    raw: boolean;
+                    /**
+                     * Asset-wide failure (the original itself is unusable, so no platform can succeed); null otherwise.
+                     */
+                    error: {
+                        code: 'media_unprobeable' | 'media_format_indeterminate' | 'media_format_unsupported' | 'media_too_large' | 'media_aspect_ratio_unsupported' | 'media_resolution_too_low' | 'media_gif_unsupported' | 'media_format_recompressed' | 'media_resolution_downscaled' | 'video_container_unsupported' | 'video_codec_unsupported' | 'video_audio_codec_unsupported' | 'video_too_large' | 'video_too_small' | 'video_dimensions_unsupported' | 'video_dimensions_too_large' | 'video_fps_unsupported' | 'video_fps_too_low' | 'video_aspect_unsupported' | 'video_duration_too_short' | 'video_duration_exceeds_max' | 'video_transform_failed' | 'media_fetch_failed' | 'document_format_unsupported' | 'document_too_large' | 'document_too_many_pages' | 'media_unsupported';
+                        message: string;
+                        hint?: string;
+                        allowed?: Array<string>;
+                        got?: string;
+                        /**
+                         * A short, friendly end-user line for `code` (render verbatim). `message` stays developer-grade; this is the display string. Size/limit codes interpolate the human cap/size.
+                         */
+                        display_error: string;
+                    } | null;
+                    source: {
+                        /**
+                         * MIME of the original, e.g. image/heic.
+                         */
+                        format: string;
+                        bytes: number;
+                        width: number | null;
+                        height: number | null;
+                        duration_ms: number | null;
+                    } | null;
+                    alt_text: string | null;
+                    per_platform: {
+                        [key: string]: {
+                            status: 'processing' | 'ready' | 'failed';
+                            /**
+                             * Public URL of this platform’s rendition (null until ready).
+                             */
+                            url: string | null;
+                            width: number | null;
+                            height: number | null;
+                            bytes: number | null;
+                            warnings: Array<{
+                                code?: unknown;
+                                message?: unknown;
+                                hint?: unknown;
+                                allowed?: unknown;
+                                got?: unknown;
+                                display_error?: unknown;
+                            }>;
+                            errors: Array<{
+                                code?: unknown;
+                                message?: unknown;
+                                hint?: unknown;
+                                allowed?: unknown;
+                                got?: unknown;
+                                display_error?: unknown;
+                            }>;
+                        };
+                    };
+                    external_id: string | null;
+                    /**
+                     * Customer-owned key/value context, returned on reads and filterable on list endpoints (exact match). Values are scalars: string (≤500 chars), number, or boolean. At most 50 keys; keys ≤40 chars; total serialized JSON must fit in 16 KiB. Arrays and nested objects are out of scope for v1 (kept out to keep the contract scalar + exact-match). Keep a key’s value type consistent across records — filtering matches type-exactly. Never derive auth/scopes from metadata.
+                     */
+                    metadata: {
+                        [key: string]: string | number | boolean;
+                    };
+                    /**
+                     * ISO-8601 creation time.
+                     */
+                    created_at: string;
+                    /**
+                     * ISO-8601 last-update time.
+                     */
+                    updated_at: string;
+                };
             }>;
         } | {
             platform: 'tiktok';
@@ -7029,6 +7781,99 @@ type PostsCreateResponses = {
                  * Per-variant alt text; falls back to the asset’s alt_text.
                  */
                 alt_text_override: string | null;
+                /**
+                 * The full media asset (kind, content_type, source dimensions, per-platform renditions) — the same shape as GET /v1/media.
+                 */
+                media: {
+                    id: string;
+                    object: 'media';
+                    profile_id: string;
+                    /**
+                     * The detected asset family (image/video/gif/document). We sniff it from the uploaded bytes. null only in the brief pre-detection window while status is `uploading`; non-null once probed.
+                     */
+                    kind: 'image' | 'video' | 'gif' | 'document' | null;
+                    /**
+                     * The detected MIME of the uploaded original (e.g. video/mp4), sniffed from the bytes. null only in the brief pre-detection window while status is `uploading`.
+                     */
+                    content_type: string | null;
+                    status: 'uploading' | 'processing' | 'ready' | 'failed';
+                    /**
+                     * In-pipeline progress: the current step (stage) and a 0–100 bar (percent). Read `status` for the outcome; `percent` can regress on a transient retry.
+                     */
+                    progress: {
+                        stage: 'queued' | 'analyzing' | 'transcoding' | 'done';
+                        percent: number;
+                    };
+                    raw: boolean;
+                    /**
+                     * Asset-wide failure (the original itself is unusable, so no platform can succeed); null otherwise.
+                     */
+                    error: {
+                        code: 'media_unprobeable' | 'media_format_indeterminate' | 'media_format_unsupported' | 'media_too_large' | 'media_aspect_ratio_unsupported' | 'media_resolution_too_low' | 'media_gif_unsupported' | 'media_format_recompressed' | 'media_resolution_downscaled' | 'video_container_unsupported' | 'video_codec_unsupported' | 'video_audio_codec_unsupported' | 'video_too_large' | 'video_too_small' | 'video_dimensions_unsupported' | 'video_dimensions_too_large' | 'video_fps_unsupported' | 'video_fps_too_low' | 'video_aspect_unsupported' | 'video_duration_too_short' | 'video_duration_exceeds_max' | 'video_transform_failed' | 'media_fetch_failed' | 'document_format_unsupported' | 'document_too_large' | 'document_too_many_pages' | 'media_unsupported';
+                        message: string;
+                        hint?: string;
+                        allowed?: Array<string>;
+                        got?: string;
+                        /**
+                         * A short, friendly end-user line for `code` (render verbatim). `message` stays developer-grade; this is the display string. Size/limit codes interpolate the human cap/size.
+                         */
+                        display_error: string;
+                    } | null;
+                    source: {
+                        /**
+                         * MIME of the original, e.g. image/heic.
+                         */
+                        format: string;
+                        bytes: number;
+                        width: number | null;
+                        height: number | null;
+                        duration_ms: number | null;
+                    } | null;
+                    alt_text: string | null;
+                    per_platform: {
+                        [key: string]: {
+                            status: 'processing' | 'ready' | 'failed';
+                            /**
+                             * Public URL of this platform’s rendition (null until ready).
+                             */
+                            url: string | null;
+                            width: number | null;
+                            height: number | null;
+                            bytes: number | null;
+                            warnings: Array<{
+                                code?: unknown;
+                                message?: unknown;
+                                hint?: unknown;
+                                allowed?: unknown;
+                                got?: unknown;
+                                display_error?: unknown;
+                            }>;
+                            errors: Array<{
+                                code?: unknown;
+                                message?: unknown;
+                                hint?: unknown;
+                                allowed?: unknown;
+                                got?: unknown;
+                                display_error?: unknown;
+                            }>;
+                        };
+                    };
+                    external_id: string | null;
+                    /**
+                     * Customer-owned key/value context, returned on reads and filterable on list endpoints (exact match). Values are scalars: string (≤500 chars), number, or boolean. At most 50 keys; keys ≤40 chars; total serialized JSON must fit in 16 KiB. Arrays and nested objects are out of scope for v1 (kept out to keep the contract scalar + exact-match). Keep a key’s value type consistent across records — filtering matches type-exactly. Never derive auth/scopes from metadata.
+                     */
+                    metadata: {
+                        [key: string]: string | number | boolean;
+                    };
+                    /**
+                     * ISO-8601 creation time.
+                     */
+                    created_at: string;
+                    /**
+                     * ISO-8601 last-update time.
+                     */
+                    updated_at: string;
+                };
             }>;
         }>;
         /**
@@ -7633,7 +8478,100 @@ type PostsGetResponses = {
                  * Per-variant alt text; falls back to the asset’s alt_text.
                  */
                 alt_text_override: string | null;
-            }>;
+                /**
+                 * The full media asset (kind, content_type, source dimensions, per-platform renditions) — the same shape as GET /v1/media.
+                 */
+                media: {
+                    id: string;
+                    object: 'media';
+                    profile_id: string;
+                    /**
+                     * The detected asset family (image/video/gif/document). We sniff it from the uploaded bytes. null only in the brief pre-detection window while status is `uploading`; non-null once probed.
+                     */
+                    kind: 'image' | 'video' | 'gif' | 'document' | null;
+                    /**
+                     * The detected MIME of the uploaded original (e.g. video/mp4), sniffed from the bytes. null only in the brief pre-detection window while status is `uploading`.
+                     */
+                    content_type: string | null;
+                    status: 'uploading' | 'processing' | 'ready' | 'failed';
+                    /**
+                     * In-pipeline progress: the current step (stage) and a 0–100 bar (percent). Read `status` for the outcome; `percent` can regress on a transient retry.
+                     */
+                    progress: {
+                        stage: 'queued' | 'analyzing' | 'transcoding' | 'done';
+                        percent: number;
+                    };
+                    raw: boolean;
+                    /**
+                     * Asset-wide failure (the original itself is unusable, so no platform can succeed); null otherwise.
+                     */
+                    error: {
+                        code: 'media_unprobeable' | 'media_format_indeterminate' | 'media_format_unsupported' | 'media_too_large' | 'media_aspect_ratio_unsupported' | 'media_resolution_too_low' | 'media_gif_unsupported' | 'media_format_recompressed' | 'media_resolution_downscaled' | 'video_container_unsupported' | 'video_codec_unsupported' | 'video_audio_codec_unsupported' | 'video_too_large' | 'video_too_small' | 'video_dimensions_unsupported' | 'video_dimensions_too_large' | 'video_fps_unsupported' | 'video_fps_too_low' | 'video_aspect_unsupported' | 'video_duration_too_short' | 'video_duration_exceeds_max' | 'video_transform_failed' | 'media_fetch_failed' | 'document_format_unsupported' | 'document_too_large' | 'document_too_many_pages' | 'media_unsupported';
+                        message: string;
+                        hint?: string;
+                        allowed?: Array<string>;
+                        got?: string;
+                        /**
+                         * A short, friendly end-user line for `code` (render verbatim). `message` stays developer-grade; this is the display string. Size/limit codes interpolate the human cap/size.
+                         */
+                        display_error: string;
+                    } | null;
+                    source: {
+                        /**
+                         * MIME of the original, e.g. image/heic.
+                         */
+                        format: string;
+                        bytes: number;
+                        width: number | null;
+                        height: number | null;
+                        duration_ms: number | null;
+                    } | null;
+                    alt_text: string | null;
+                    per_platform: {
+                        [key: string]: {
+                            status: 'processing' | 'ready' | 'failed';
+                            /**
+                             * Public URL of this platform’s rendition (null until ready).
+                             */
+                            url: string | null;
+                            width: number | null;
+                            height: number | null;
+                            bytes: number | null;
+                            warnings: Array<{
+                                code?: unknown;
+                                message?: unknown;
+                                hint?: unknown;
+                                allowed?: unknown;
+                                got?: unknown;
+                                display_error?: unknown;
+                            }>;
+                            errors: Array<{
+                                code?: unknown;
+                                message?: unknown;
+                                hint?: unknown;
+                                allowed?: unknown;
+                                got?: unknown;
+                                display_error?: unknown;
+                            }>;
+                        };
+                    };
+                    external_id: string | null;
+                    /**
+                     * Customer-owned key/value context, returned on reads and filterable on list endpoints (exact match). Values are scalars: string (≤500 chars), number, or boolean. At most 50 keys; keys ≤40 chars; total serialized JSON must fit in 16 KiB. Arrays and nested objects are out of scope for v1 (kept out to keep the contract scalar + exact-match). Keep a key’s value type consistent across records — filtering matches type-exactly. Never derive auth/scopes from metadata.
+                     */
+                    metadata: {
+                        [key: string]: string | number | boolean;
+                    };
+                    /**
+                     * ISO-8601 creation time.
+                     */
+                    created_at: string;
+                    /**
+                     * ISO-8601 last-update time.
+                     */
+                    updated_at: string;
+                };
+            }>;
         } | {
             platform: 'linkedin';
             post_type: 'text' | 'single_image' | 'multi_image' | 'video';
@@ -7759,6 +8697,99 @@ type PostsGetResponses = {
                  * Per-variant alt text; falls back to the asset’s alt_text.
                  */
                 alt_text_override: string | null;
+                /**
+                 * The full media asset (kind, content_type, source dimensions, per-platform renditions) — the same shape as GET /v1/media.
+                 */
+                media: {
+                    id: string;
+                    object: 'media';
+                    profile_id: string;
+                    /**
+                     * The detected asset family (image/video/gif/document). We sniff it from the uploaded bytes. null only in the brief pre-detection window while status is `uploading`; non-null once probed.
+                     */
+                    kind: 'image' | 'video' | 'gif' | 'document' | null;
+                    /**
+                     * The detected MIME of the uploaded original (e.g. video/mp4), sniffed from the bytes. null only in the brief pre-detection window while status is `uploading`.
+                     */
+                    content_type: string | null;
+                    status: 'uploading' | 'processing' | 'ready' | 'failed';
+                    /**
+                     * In-pipeline progress: the current step (stage) and a 0–100 bar (percent). Read `status` for the outcome; `percent` can regress on a transient retry.
+                     */
+                    progress: {
+                        stage: 'queued' | 'analyzing' | 'transcoding' | 'done';
+                        percent: number;
+                    };
+                    raw: boolean;
+                    /**
+                     * Asset-wide failure (the original itself is unusable, so no platform can succeed); null otherwise.
+                     */
+                    error: {
+                        code: 'media_unprobeable' | 'media_format_indeterminate' | 'media_format_unsupported' | 'media_too_large' | 'media_aspect_ratio_unsupported' | 'media_resolution_too_low' | 'media_gif_unsupported' | 'media_format_recompressed' | 'media_resolution_downscaled' | 'video_container_unsupported' | 'video_codec_unsupported' | 'video_audio_codec_unsupported' | 'video_too_large' | 'video_too_small' | 'video_dimensions_unsupported' | 'video_dimensions_too_large' | 'video_fps_unsupported' | 'video_fps_too_low' | 'video_aspect_unsupported' | 'video_duration_too_short' | 'video_duration_exceeds_max' | 'video_transform_failed' | 'media_fetch_failed' | 'document_format_unsupported' | 'document_too_large' | 'document_too_many_pages' | 'media_unsupported';
+                        message: string;
+                        hint?: string;
+                        allowed?: Array<string>;
+                        got?: string;
+                        /**
+                         * A short, friendly end-user line for `code` (render verbatim). `message` stays developer-grade; this is the display string. Size/limit codes interpolate the human cap/size.
+                         */
+                        display_error: string;
+                    } | null;
+                    source: {
+                        /**
+                         * MIME of the original, e.g. image/heic.
+                         */
+                        format: string;
+                        bytes: number;
+                        width: number | null;
+                        height: number | null;
+                        duration_ms: number | null;
+                    } | null;
+                    alt_text: string | null;
+                    per_platform: {
+                        [key: string]: {
+                            status: 'processing' | 'ready' | 'failed';
+                            /**
+                             * Public URL of this platform’s rendition (null until ready).
+                             */
+                            url: string | null;
+                            width: number | null;
+                            height: number | null;
+                            bytes: number | null;
+                            warnings: Array<{
+                                code?: unknown;
+                                message?: unknown;
+                                hint?: unknown;
+                                allowed?: unknown;
+                                got?: unknown;
+                                display_error?: unknown;
+                            }>;
+                            errors: Array<{
+                                code?: unknown;
+                                message?: unknown;
+                                hint?: unknown;
+                                allowed?: unknown;
+                                got?: unknown;
+                                display_error?: unknown;
+                            }>;
+                        };
+                    };
+                    external_id: string | null;
+                    /**
+                     * Customer-owned key/value context, returned on reads and filterable on list endpoints (exact match). Values are scalars: string (≤500 chars), number, or boolean. At most 50 keys; keys ≤40 chars; total serialized JSON must fit in 16 KiB. Arrays and nested objects are out of scope for v1 (kept out to keep the contract scalar + exact-match). Keep a key’s value type consistent across records — filtering matches type-exactly. Never derive auth/scopes from metadata.
+                     */
+                    metadata: {
+                        [key: string]: string | number | boolean;
+                    };
+                    /**
+                     * ISO-8601 creation time.
+                     */
+                    created_at: string;
+                    /**
+                     * ISO-8601 last-update time.
+                     */
+                    updated_at: string;
+                };
             }>;
         } | {
             platform: 'facebook_page';
@@ -7813,6 +8844,99 @@ type PostsGetResponses = {
                  * Per-variant alt text; falls back to the asset’s alt_text.
                  */
                 alt_text_override: string | null;
+                /**
+                 * The full media asset (kind, content_type, source dimensions, per-platform renditions) — the same shape as GET /v1/media.
+                 */
+                media: {
+                    id: string;
+                    object: 'media';
+                    profile_id: string;
+                    /**
+                     * The detected asset family (image/video/gif/document). We sniff it from the uploaded bytes. null only in the brief pre-detection window while status is `uploading`; non-null once probed.
+                     */
+                    kind: 'image' | 'video' | 'gif' | 'document' | null;
+                    /**
+                     * The detected MIME of the uploaded original (e.g. video/mp4), sniffed from the bytes. null only in the brief pre-detection window while status is `uploading`.
+                     */
+                    content_type: string | null;
+                    status: 'uploading' | 'processing' | 'ready' | 'failed';
+                    /**
+                     * In-pipeline progress: the current step (stage) and a 0–100 bar (percent). Read `status` for the outcome; `percent` can regress on a transient retry.
+                     */
+                    progress: {
+                        stage: 'queued' | 'analyzing' | 'transcoding' | 'done';
+                        percent: number;
+                    };
+                    raw: boolean;
+                    /**
+                     * Asset-wide failure (the original itself is unusable, so no platform can succeed); null otherwise.
+                     */
+                    error: {
+                        code: 'media_unprobeable' | 'media_format_indeterminate' | 'media_format_unsupported' | 'media_too_large' | 'media_aspect_ratio_unsupported' | 'media_resolution_too_low' | 'media_gif_unsupported' | 'media_format_recompressed' | 'media_resolution_downscaled' | 'video_container_unsupported' | 'video_codec_unsupported' | 'video_audio_codec_unsupported' | 'video_too_large' | 'video_too_small' | 'video_dimensions_unsupported' | 'video_dimensions_too_large' | 'video_fps_unsupported' | 'video_fps_too_low' | 'video_aspect_unsupported' | 'video_duration_too_short' | 'video_duration_exceeds_max' | 'video_transform_failed' | 'media_fetch_failed' | 'document_format_unsupported' | 'document_too_large' | 'document_too_many_pages' | 'media_unsupported';
+                        message: string;
+                        hint?: string;
+                        allowed?: Array<string>;
+                        got?: string;
+                        /**
+                         * A short, friendly end-user line for `code` (render verbatim). `message` stays developer-grade; this is the display string. Size/limit codes interpolate the human cap/size.
+                         */
+                        display_error: string;
+                    } | null;
+                    source: {
+                        /**
+                         * MIME of the original, e.g. image/heic.
+                         */
+                        format: string;
+                        bytes: number;
+                        width: number | null;
+                        height: number | null;
+                        duration_ms: number | null;
+                    } | null;
+                    alt_text: string | null;
+                    per_platform: {
+                        [key: string]: {
+                            status: 'processing' | 'ready' | 'failed';
+                            /**
+                             * Public URL of this platform’s rendition (null until ready).
+                             */
+                            url: string | null;
+                            width: number | null;
+                            height: number | null;
+                            bytes: number | null;
+                            warnings: Array<{
+                                code?: unknown;
+                                message?: unknown;
+                                hint?: unknown;
+                                allowed?: unknown;
+                                got?: unknown;
+                                display_error?: unknown;
+                            }>;
+                            errors: Array<{
+                                code?: unknown;
+                                message?: unknown;
+                                hint?: unknown;
+                                allowed?: unknown;
+                                got?: unknown;
+                                display_error?: unknown;
+                            }>;
+                        };
+                    };
+                    external_id: string | null;
+                    /**
+                     * Customer-owned key/value context, returned on reads and filterable on list endpoints (exact match). Values are scalars: string (≤500 chars), number, or boolean. At most 50 keys; keys ≤40 chars; total serialized JSON must fit in 16 KiB. Arrays and nested objects are out of scope for v1 (kept out to keep the contract scalar + exact-match). Keep a key’s value type consistent across records — filtering matches type-exactly. Never derive auth/scopes from metadata.
+                     */
+                    metadata: {
+                        [key: string]: string | number | boolean;
+                    };
+                    /**
+                     * ISO-8601 creation time.
+                     */
+                    created_at: string;
+                    /**
+                     * ISO-8601 last-update time.
+                     */
+                    updated_at: string;
+                };
             }>;
         } | {
             platform: 'instagram';
@@ -7908,6 +9032,99 @@ type PostsGetResponses = {
                  * Per-variant alt text; falls back to the asset’s alt_text.
                  */
                 alt_text_override: string | null;
+                /**
+                 * The full media asset (kind, content_type, source dimensions, per-platform renditions) — the same shape as GET /v1/media.
+                 */
+                media: {
+                    id: string;
+                    object: 'media';
+                    profile_id: string;
+                    /**
+                     * The detected asset family (image/video/gif/document). We sniff it from the uploaded bytes. null only in the brief pre-detection window while status is `uploading`; non-null once probed.
+                     */
+                    kind: 'image' | 'video' | 'gif' | 'document' | null;
+                    /**
+                     * The detected MIME of the uploaded original (e.g. video/mp4), sniffed from the bytes. null only in the brief pre-detection window while status is `uploading`.
+                     */
+                    content_type: string | null;
+                    status: 'uploading' | 'processing' | 'ready' | 'failed';
+                    /**
+                     * In-pipeline progress: the current step (stage) and a 0–100 bar (percent). Read `status` for the outcome; `percent` can regress on a transient retry.
+                     */
+                    progress: {
+                        stage: 'queued' | 'analyzing' | 'transcoding' | 'done';
+                        percent: number;
+                    };
+                    raw: boolean;
+                    /**
+                     * Asset-wide failure (the original itself is unusable, so no platform can succeed); null otherwise.
+                     */
+                    error: {
+                        code: 'media_unprobeable' | 'media_format_indeterminate' | 'media_format_unsupported' | 'media_too_large' | 'media_aspect_ratio_unsupported' | 'media_resolution_too_low' | 'media_gif_unsupported' | 'media_format_recompressed' | 'media_resolution_downscaled' | 'video_container_unsupported' | 'video_codec_unsupported' | 'video_audio_codec_unsupported' | 'video_too_large' | 'video_too_small' | 'video_dimensions_unsupported' | 'video_dimensions_too_large' | 'video_fps_unsupported' | 'video_fps_too_low' | 'video_aspect_unsupported' | 'video_duration_too_short' | 'video_duration_exceeds_max' | 'video_transform_failed' | 'media_fetch_failed' | 'document_format_unsupported' | 'document_too_large' | 'document_too_many_pages' | 'media_unsupported';
+                        message: string;
+                        hint?: string;
+                        allowed?: Array<string>;
+                        got?: string;
+                        /**
+                         * A short, friendly end-user line for `code` (render verbatim). `message` stays developer-grade; this is the display string. Size/limit codes interpolate the human cap/size.
+                         */
+                        display_error: string;
+                    } | null;
+                    source: {
+                        /**
+                         * MIME of the original, e.g. image/heic.
+                         */
+                        format: string;
+                        bytes: number;
+                        width: number | null;
+                        height: number | null;
+                        duration_ms: number | null;
+                    } | null;
+                    alt_text: string | null;
+                    per_platform: {
+                        [key: string]: {
+                            status: 'processing' | 'ready' | 'failed';
+                            /**
+                             * Public URL of this platform’s rendition (null until ready).
+                             */
+                            url: string | null;
+                            width: number | null;
+                            height: number | null;
+                            bytes: number | null;
+                            warnings: Array<{
+                                code?: unknown;
+                                message?: unknown;
+                                hint?: unknown;
+                                allowed?: unknown;
+                                got?: unknown;
+                                display_error?: unknown;
+                            }>;
+                            errors: Array<{
+                                code?: unknown;
+                                message?: unknown;
+                                hint?: unknown;
+                                allowed?: unknown;
+                                got?: unknown;
+                                display_error?: unknown;
+                            }>;
+                        };
+                    };
+                    external_id: string | null;
+                    /**
+                     * Customer-owned key/value context, returned on reads and filterable on list endpoints (exact match). Values are scalars: string (≤500 chars), number, or boolean. At most 50 keys; keys ≤40 chars; total serialized JSON must fit in 16 KiB. Arrays and nested objects are out of scope for v1 (kept out to keep the contract scalar + exact-match). Keep a key’s value type consistent across records — filtering matches type-exactly. Never derive auth/scopes from metadata.
+                     */
+                    metadata: {
+                        [key: string]: string | number | boolean;
+                    };
+                    /**
+                     * ISO-8601 creation time.
+                     */
+                    created_at: string;
+                    /**
+                     * ISO-8601 last-update time.
+                     */
+                    updated_at: string;
+                };
             }>;
         } | {
             platform: 'tiktok';
@@ -7998,6 +9215,99 @@ type PostsGetResponses = {
                  * Per-variant alt text; falls back to the asset’s alt_text.
                  */
                 alt_text_override: string | null;
+                /**
+                 * The full media asset (kind, content_type, source dimensions, per-platform renditions) — the same shape as GET /v1/media.
+                 */
+                media: {
+                    id: string;
+                    object: 'media';
+                    profile_id: string;
+                    /**
+                     * The detected asset family (image/video/gif/document). We sniff it from the uploaded bytes. null only in the brief pre-detection window while status is `uploading`; non-null once probed.
+                     */
+                    kind: 'image' | 'video' | 'gif' | 'document' | null;
+                    /**
+                     * The detected MIME of the uploaded original (e.g. video/mp4), sniffed from the bytes. null only in the brief pre-detection window while status is `uploading`.
+                     */
+                    content_type: string | null;
+                    status: 'uploading' | 'processing' | 'ready' | 'failed';
+                    /**
+                     * In-pipeline progress: the current step (stage) and a 0–100 bar (percent). Read `status` for the outcome; `percent` can regress on a transient retry.
+                     */
+                    progress: {
+                        stage: 'queued' | 'analyzing' | 'transcoding' | 'done';
+                        percent: number;
+                    };
+                    raw: boolean;
+                    /**
+                     * Asset-wide failure (the original itself is unusable, so no platform can succeed); null otherwise.
+                     */
+                    error: {
+                        code: 'media_unprobeable' | 'media_format_indeterminate' | 'media_format_unsupported' | 'media_too_large' | 'media_aspect_ratio_unsupported' | 'media_resolution_too_low' | 'media_gif_unsupported' | 'media_format_recompressed' | 'media_resolution_downscaled' | 'video_container_unsupported' | 'video_codec_unsupported' | 'video_audio_codec_unsupported' | 'video_too_large' | 'video_too_small' | 'video_dimensions_unsupported' | 'video_dimensions_too_large' | 'video_fps_unsupported' | 'video_fps_too_low' | 'video_aspect_unsupported' | 'video_duration_too_short' | 'video_duration_exceeds_max' | 'video_transform_failed' | 'media_fetch_failed' | 'document_format_unsupported' | 'document_too_large' | 'document_too_many_pages' | 'media_unsupported';
+                        message: string;
+                        hint?: string;
+                        allowed?: Array<string>;
+                        got?: string;
+                        /**
+                         * A short, friendly end-user line for `code` (render verbatim). `message` stays developer-grade; this is the display string. Size/limit codes interpolate the human cap/size.
+                         */
+                        display_error: string;
+                    } | null;
+                    source: {
+                        /**
+                         * MIME of the original, e.g. image/heic.
+                         */
+                        format: string;
+                        bytes: number;
+                        width: number | null;
+                        height: number | null;
+                        duration_ms: number | null;
+                    } | null;
+                    alt_text: string | null;
+                    per_platform: {
+                        [key: string]: {
+                            status: 'processing' | 'ready' | 'failed';
+                            /**
+                             * Public URL of this platform’s rendition (null until ready).
+                             */
+                            url: string | null;
+                            width: number | null;
+                            height: number | null;
+                            bytes: number | null;
+                            warnings: Array<{
+                                code?: unknown;
+                                message?: unknown;
+                                hint?: unknown;
+                                allowed?: unknown;
+                                got?: unknown;
+                                display_error?: unknown;
+                            }>;
+                            errors: Array<{
+                                code?: unknown;
+                                message?: unknown;
+                                hint?: unknown;
+                                allowed?: unknown;
+                                got?: unknown;
+                                display_error?: unknown;
+                            }>;
+                        };
+                    };
+                    external_id: string | null;
+                    /**
+                     * Customer-owned key/value context, returned on reads and filterable on list endpoints (exact match). Values are scalars: string (≤500 chars), number, or boolean. At most 50 keys; keys ≤40 chars; total serialized JSON must fit in 16 KiB. Arrays and nested objects are out of scope for v1 (kept out to keep the contract scalar + exact-match). Keep a key’s value type consistent across records — filtering matches type-exactly. Never derive auth/scopes from metadata.
+                     */
+                    metadata: {
+                        [key: string]: string | number | boolean;
+                    };
+                    /**
+                     * ISO-8601 creation time.
+                     */
+                    created_at: string;
+                    /**
+                     * ISO-8601 last-update time.
+                     */
+                    updated_at: string;
+                };
             }>;
         }>;
         /**
@@ -8801,6 +10111,99 @@ type PostsUpdateResponses = {
                  * Per-variant alt text; falls back to the asset’s alt_text.
                  */
                 alt_text_override: string | null;
+                /**
+                 * The full media asset (kind, content_type, source dimensions, per-platform renditions) — the same shape as GET /v1/media.
+                 */
+                media: {
+                    id: string;
+                    object: 'media';
+                    profile_id: string;
+                    /**
+                     * The detected asset family (image/video/gif/document). We sniff it from the uploaded bytes. null only in the brief pre-detection window while status is `uploading`; non-null once probed.
+                     */
+                    kind: 'image' | 'video' | 'gif' | 'document' | null;
+                    /**
+                     * The detected MIME of the uploaded original (e.g. video/mp4), sniffed from the bytes. null only in the brief pre-detection window while status is `uploading`.
+                     */
+                    content_type: string | null;
+                    status: 'uploading' | 'processing' | 'ready' | 'failed';
+                    /**
+                     * In-pipeline progress: the current step (stage) and a 0–100 bar (percent). Read `status` for the outcome; `percent` can regress on a transient retry.
+                     */
+                    progress: {
+                        stage: 'queued' | 'analyzing' | 'transcoding' | 'done';
+                        percent: number;
+                    };
+                    raw: boolean;
+                    /**
+                     * Asset-wide failure (the original itself is unusable, so no platform can succeed); null otherwise.
+                     */
+                    error: {
+                        code: 'media_unprobeable' | 'media_format_indeterminate' | 'media_format_unsupported' | 'media_too_large' | 'media_aspect_ratio_unsupported' | 'media_resolution_too_low' | 'media_gif_unsupported' | 'media_format_recompressed' | 'media_resolution_downscaled' | 'video_container_unsupported' | 'video_codec_unsupported' | 'video_audio_codec_unsupported' | 'video_too_large' | 'video_too_small' | 'video_dimensions_unsupported' | 'video_dimensions_too_large' | 'video_fps_unsupported' | 'video_fps_too_low' | 'video_aspect_unsupported' | 'video_duration_too_short' | 'video_duration_exceeds_max' | 'video_transform_failed' | 'media_fetch_failed' | 'document_format_unsupported' | 'document_too_large' | 'document_too_many_pages' | 'media_unsupported';
+                        message: string;
+                        hint?: string;
+                        allowed?: Array<string>;
+                        got?: string;
+                        /**
+                         * A short, friendly end-user line for `code` (render verbatim). `message` stays developer-grade; this is the display string. Size/limit codes interpolate the human cap/size.
+                         */
+                        display_error: string;
+                    } | null;
+                    source: {
+                        /**
+                         * MIME of the original, e.g. image/heic.
+                         */
+                        format: string;
+                        bytes: number;
+                        width: number | null;
+                        height: number | null;
+                        duration_ms: number | null;
+                    } | null;
+                    alt_text: string | null;
+                    per_platform: {
+                        [key: string]: {
+                            status: 'processing' | 'ready' | 'failed';
+                            /**
+                             * Public URL of this platform’s rendition (null until ready).
+                             */
+                            url: string | null;
+                            width: number | null;
+                            height: number | null;
+                            bytes: number | null;
+                            warnings: Array<{
+                                code?: unknown;
+                                message?: unknown;
+                                hint?: unknown;
+                                allowed?: unknown;
+                                got?: unknown;
+                                display_error?: unknown;
+                            }>;
+                            errors: Array<{
+                                code?: unknown;
+                                message?: unknown;
+                                hint?: unknown;
+                                allowed?: unknown;
+                                got?: unknown;
+                                display_error?: unknown;
+                            }>;
+                        };
+                    };
+                    external_id: string | null;
+                    /**
+                     * Customer-owned key/value context, returned on reads and filterable on list endpoints (exact match). Values are scalars: string (≤500 chars), number, or boolean. At most 50 keys; keys ≤40 chars; total serialized JSON must fit in 16 KiB. Arrays and nested objects are out of scope for v1 (kept out to keep the contract scalar + exact-match). Keep a key’s value type consistent across records — filtering matches type-exactly. Never derive auth/scopes from metadata.
+                     */
+                    metadata: {
+                        [key: string]: string | number | boolean;
+                    };
+                    /**
+                     * ISO-8601 creation time.
+                     */
+                    created_at: string;
+                    /**
+                     * ISO-8601 last-update time.
+                     */
+                    updated_at: string;
+                };
             }>;
         } | {
             platform: 'linkedin';
@@ -8927,6 +10330,99 @@ type PostsUpdateResponses = {
                  * Per-variant alt text; falls back to the asset’s alt_text.
                  */
                 alt_text_override: string | null;
+                /**
+                 * The full media asset (kind, content_type, source dimensions, per-platform renditions) — the same shape as GET /v1/media.
+                 */
+                media: {
+                    id: string;
+                    object: 'media';
+                    profile_id: string;
+                    /**
+                     * The detected asset family (image/video/gif/document). We sniff it from the uploaded bytes. null only in the brief pre-detection window while status is `uploading`; non-null once probed.
+                     */
+                    kind: 'image' | 'video' | 'gif' | 'document' | null;
+                    /**
+                     * The detected MIME of the uploaded original (e.g. video/mp4), sniffed from the bytes. null only in the brief pre-detection window while status is `uploading`.
+                     */
+                    content_type: string | null;
+                    status: 'uploading' | 'processing' | 'ready' | 'failed';
+                    /**
+                     * In-pipeline progress: the current step (stage) and a 0–100 bar (percent). Read `status` for the outcome; `percent` can regress on a transient retry.
+                     */
+                    progress: {
+                        stage: 'queued' | 'analyzing' | 'transcoding' | 'done';
+                        percent: number;
+                    };
+                    raw: boolean;
+                    /**
+                     * Asset-wide failure (the original itself is unusable, so no platform can succeed); null otherwise.
+                     */
+                    error: {
+                        code: 'media_unprobeable' | 'media_format_indeterminate' | 'media_format_unsupported' | 'media_too_large' | 'media_aspect_ratio_unsupported' | 'media_resolution_too_low' | 'media_gif_unsupported' | 'media_format_recompressed' | 'media_resolution_downscaled' | 'video_container_unsupported' | 'video_codec_unsupported' | 'video_audio_codec_unsupported' | 'video_too_large' | 'video_too_small' | 'video_dimensions_unsupported' | 'video_dimensions_too_large' | 'video_fps_unsupported' | 'video_fps_too_low' | 'video_aspect_unsupported' | 'video_duration_too_short' | 'video_duration_exceeds_max' | 'video_transform_failed' | 'media_fetch_failed' | 'document_format_unsupported' | 'document_too_large' | 'document_too_many_pages' | 'media_unsupported';
+                        message: string;
+                        hint?: string;
+                        allowed?: Array<string>;
+                        got?: string;
+                        /**
+                         * A short, friendly end-user line for `code` (render verbatim). `message` stays developer-grade; this is the display string. Size/limit codes interpolate the human cap/size.
+                         */
+                        display_error: string;
+                    } | null;
+                    source: {
+                        /**
+                         * MIME of the original, e.g. image/heic.
+                         */
+                        format: string;
+                        bytes: number;
+                        width: number | null;
+                        height: number | null;
+                        duration_ms: number | null;
+                    } | null;
+                    alt_text: string | null;
+                    per_platform: {
+                        [key: string]: {
+                            status: 'processing' | 'ready' | 'failed';
+                            /**
+                             * Public URL of this platform’s rendition (null until ready).
+                             */
+                            url: string | null;
+                            width: number | null;
+                            height: number | null;
+                            bytes: number | null;
+                            warnings: Array<{
+                                code?: unknown;
+                                message?: unknown;
+                                hint?: unknown;
+                                allowed?: unknown;
+                                got?: unknown;
+                                display_error?: unknown;
+                            }>;
+                            errors: Array<{
+                                code?: unknown;
+                                message?: unknown;
+                                hint?: unknown;
+                                allowed?: unknown;
+                                got?: unknown;
+                                display_error?: unknown;
+                            }>;
+                        };
+                    };
+                    external_id: string | null;
+                    /**
+                     * Customer-owned key/value context, returned on reads and filterable on list endpoints (exact match). Values are scalars: string (≤500 chars), number, or boolean. At most 50 keys; keys ≤40 chars; total serialized JSON must fit in 16 KiB. Arrays and nested objects are out of scope for v1 (kept out to keep the contract scalar + exact-match). Keep a key’s value type consistent across records — filtering matches type-exactly. Never derive auth/scopes from metadata.
+                     */
+                    metadata: {
+                        [key: string]: string | number | boolean;
+                    };
+                    /**
+                     * ISO-8601 creation time.
+                     */
+                    created_at: string;
+                    /**
+                     * ISO-8601 last-update time.
+                     */
+                    updated_at: string;
+                };
             }>;
         } | {
             platform: 'facebook_page';
@@ -8981,6 +10477,99 @@ type PostsUpdateResponses = {
                  * Per-variant alt text; falls back to the asset’s alt_text.
                  */
                 alt_text_override: string | null;
+                /**
+                 * The full media asset (kind, content_type, source dimensions, per-platform renditions) — the same shape as GET /v1/media.
+                 */
+                media: {
+                    id: string;
+                    object: 'media';
+                    profile_id: string;
+                    /**
+                     * The detected asset family (image/video/gif/document). We sniff it from the uploaded bytes. null only in the brief pre-detection window while status is `uploading`; non-null once probed.
+                     */
+                    kind: 'image' | 'video' | 'gif' | 'document' | null;
+                    /**
+                     * The detected MIME of the uploaded original (e.g. video/mp4), sniffed from the bytes. null only in the brief pre-detection window while status is `uploading`.
+                     */
+                    content_type: string | null;
+                    status: 'uploading' | 'processing' | 'ready' | 'failed';
+                    /**
+                     * In-pipeline progress: the current step (stage) and a 0–100 bar (percent). Read `status` for the outcome; `percent` can regress on a transient retry.
+                     */
+                    progress: {
+                        stage: 'queued' | 'analyzing' | 'transcoding' | 'done';
+                        percent: number;
+                    };
+                    raw: boolean;
+                    /**
+                     * Asset-wide failure (the original itself is unusable, so no platform can succeed); null otherwise.
+                     */
+                    error: {
+                        code: 'media_unprobeable' | 'media_format_indeterminate' | 'media_format_unsupported' | 'media_too_large' | 'media_aspect_ratio_unsupported' | 'media_resolution_too_low' | 'media_gif_unsupported' | 'media_format_recompressed' | 'media_resolution_downscaled' | 'video_container_unsupported' | 'video_codec_unsupported' | 'video_audio_codec_unsupported' | 'video_too_large' | 'video_too_small' | 'video_dimensions_unsupported' | 'video_dimensions_too_large' | 'video_fps_unsupported' | 'video_fps_too_low' | 'video_aspect_unsupported' | 'video_duration_too_short' | 'video_duration_exceeds_max' | 'video_transform_failed' | 'media_fetch_failed' | 'document_format_unsupported' | 'document_too_large' | 'document_too_many_pages' | 'media_unsupported';
+                        message: string;
+                        hint?: string;
+                        allowed?: Array<string>;
+                        got?: string;
+                        /**
+                         * A short, friendly end-user line for `code` (render verbatim). `message` stays developer-grade; this is the display string. Size/limit codes interpolate the human cap/size.
+                         */
+                        display_error: string;
+                    } | null;
+                    source: {
+                        /**
+                         * MIME of the original, e.g. image/heic.
+                         */
+                        format: string;
+                        bytes: number;
+                        width: number | null;
+                        height: number | null;
+                        duration_ms: number | null;
+                    } | null;
+                    alt_text: string | null;
+                    per_platform: {
+                        [key: string]: {
+                            status: 'processing' | 'ready' | 'failed';
+                            /**
+                             * Public URL of this platform’s rendition (null until ready).
+                             */
+                            url: string | null;
+                            width: number | null;
+                            height: number | null;
+                            bytes: number | null;
+                            warnings: Array<{
+                                code?: unknown;
+                                message?: unknown;
+                                hint?: unknown;
+                                allowed?: unknown;
+                                got?: unknown;
+                                display_error?: unknown;
+                            }>;
+                            errors: Array<{
+                                code?: unknown;
+                                message?: unknown;
+                                hint?: unknown;
+                                allowed?: unknown;
+                                got?: unknown;
+                                display_error?: unknown;
+                            }>;
+                        };
+                    };
+                    external_id: string | null;
+                    /**
+                     * Customer-owned key/value context, returned on reads and filterable on list endpoints (exact match). Values are scalars: string (≤500 chars), number, or boolean. At most 50 keys; keys ≤40 chars; total serialized JSON must fit in 16 KiB. Arrays and nested objects are out of scope for v1 (kept out to keep the contract scalar + exact-match). Keep a key’s value type consistent across records — filtering matches type-exactly. Never derive auth/scopes from metadata.
+                     */
+                    metadata: {
+                        [key: string]: string | number | boolean;
+                    };
+                    /**
+                     * ISO-8601 creation time.
+                     */
+                    created_at: string;
+                    /**
+                     * ISO-8601 last-update time.
+                     */
+                    updated_at: string;
+                };
             }>;
         } | {
             platform: 'instagram';
@@ -9076,6 +10665,99 @@ type PostsUpdateResponses = {
                  * Per-variant alt text; falls back to the asset’s alt_text.
                  */
                 alt_text_override: string | null;
+                /**
+                 * The full media asset (kind, content_type, source dimensions, per-platform renditions) — the same shape as GET /v1/media.
+                 */
+                media: {
+                    id: string;
+                    object: 'media';
+                    profile_id: string;
+                    /**
+                     * The detected asset family (image/video/gif/document). We sniff it from the uploaded bytes. null only in the brief pre-detection window while status is `uploading`; non-null once probed.
+                     */
+                    kind: 'image' | 'video' | 'gif' | 'document' | null;
+                    /**
+                     * The detected MIME of the uploaded original (e.g. video/mp4), sniffed from the bytes. null only in the brief pre-detection window while status is `uploading`.
+                     */
+                    content_type: string | null;
+                    status: 'uploading' | 'processing' | 'ready' | 'failed';
+                    /**
+                     * In-pipeline progress: the current step (stage) and a 0–100 bar (percent). Read `status` for the outcome; `percent` can regress on a transient retry.
+                     */
+                    progress: {
+                        stage: 'queued' | 'analyzing' | 'transcoding' | 'done';
+                        percent: number;
+                    };
+                    raw: boolean;
+                    /**
+                     * Asset-wide failure (the original itself is unusable, so no platform can succeed); null otherwise.
+                     */
+                    error: {
+                        code: 'media_unprobeable' | 'media_format_indeterminate' | 'media_format_unsupported' | 'media_too_large' | 'media_aspect_ratio_unsupported' | 'media_resolution_too_low' | 'media_gif_unsupported' | 'media_format_recompressed' | 'media_resolution_downscaled' | 'video_container_unsupported' | 'video_codec_unsupported' | 'video_audio_codec_unsupported' | 'video_too_large' | 'video_too_small' | 'video_dimensions_unsupported' | 'video_dimensions_too_large' | 'video_fps_unsupported' | 'video_fps_too_low' | 'video_aspect_unsupported' | 'video_duration_too_short' | 'video_duration_exceeds_max' | 'video_transform_failed' | 'media_fetch_failed' | 'document_format_unsupported' | 'document_too_large' | 'document_too_many_pages' | 'media_unsupported';
+                        message: string;
+                        hint?: string;
+                        allowed?: Array<string>;
+                        got?: string;
+                        /**
+                         * A short, friendly end-user line for `code` (render verbatim). `message` stays developer-grade; this is the display string. Size/limit codes interpolate the human cap/size.
+                         */
+                        display_error: string;
+                    } | null;
+                    source: {
+                        /**
+                         * MIME of the original, e.g. image/heic.
+                         */
+                        format: string;
+                        bytes: number;
+                        width: number | null;
+                        height: number | null;
+                        duration_ms: number | null;
+                    } | null;
+                    alt_text: string | null;
+                    per_platform: {
+                        [key: string]: {
+                            status: 'processing' | 'ready' | 'failed';
+                            /**
+                             * Public URL of this platform’s rendition (null until ready).
+                             */
+                            url: string | null;
+                            width: number | null;
+                            height: number | null;
+                            bytes: number | null;
+                            warnings: Array<{
+                                code?: unknown;
+                                message?: unknown;
+                                hint?: unknown;
+                                allowed?: unknown;
+                                got?: unknown;
+                                display_error?: unknown;
+                            }>;
+                            errors: Array<{
+                                code?: unknown;
+                                message?: unknown;
+                                hint?: unknown;
+                                allowed?: unknown;
+                                got?: unknown;
+                                display_error?: unknown;
+                            }>;
+                        };
+                    };
+                    external_id: string | null;
+                    /**
+                     * Customer-owned key/value context, returned on reads and filterable on list endpoints (exact match). Values are scalars: string (≤500 chars), number, or boolean. At most 50 keys; keys ≤40 chars; total serialized JSON must fit in 16 KiB. Arrays and nested objects are out of scope for v1 (kept out to keep the contract scalar + exact-match). Keep a key’s value type consistent across records — filtering matches type-exactly. Never derive auth/scopes from metadata.
+                     */
+                    metadata: {
+                        [key: string]: string | number | boolean;
+                    };
+                    /**
+                     * ISO-8601 creation time.
+                     */
+                    created_at: string;
+                    /**
+                     * ISO-8601 last-update time.
+                     */
+                    updated_at: string;
+                };
             }>;
         } | {
             platform: 'tiktok';
@@ -9166,6 +10848,99 @@ type PostsUpdateResponses = {
                  * Per-variant alt text; falls back to the asset’s alt_text.
                  */
                 alt_text_override: string | null;
+                /**
+                 * The full media asset (kind, content_type, source dimensions, per-platform renditions) — the same shape as GET /v1/media.
+                 */
+                media: {
+                    id: string;
+                    object: 'media';
+                    profile_id: string;
+                    /**
+                     * The detected asset family (image/video/gif/document). We sniff it from the uploaded bytes. null only in the brief pre-detection window while status is `uploading`; non-null once probed.
+                     */
+                    kind: 'image' | 'video' | 'gif' | 'document' | null;
+                    /**
+                     * The detected MIME of the uploaded original (e.g. video/mp4), sniffed from the bytes. null only in the brief pre-detection window while status is `uploading`.
+                     */
+                    content_type: string | null;
+                    status: 'uploading' | 'processing' | 'ready' | 'failed';
+                    /**
+                     * In-pipeline progress: the current step (stage) and a 0–100 bar (percent). Read `status` for the outcome; `percent` can regress on a transient retry.
+                     */
+                    progress: {
+                        stage: 'queued' | 'analyzing' | 'transcoding' | 'done';
+                        percent: number;
+                    };
+                    raw: boolean;
+                    /**
+                     * Asset-wide failure (the original itself is unusable, so no platform can succeed); null otherwise.
+                     */
+                    error: {
+                        code: 'media_unprobeable' | 'media_format_indeterminate' | 'media_format_unsupported' | 'media_too_large' | 'media_aspect_ratio_unsupported' | 'media_resolution_too_low' | 'media_gif_unsupported' | 'media_format_recompressed' | 'media_resolution_downscaled' | 'video_container_unsupported' | 'video_codec_unsupported' | 'video_audio_codec_unsupported' | 'video_too_large' | 'video_too_small' | 'video_dimensions_unsupported' | 'video_dimensions_too_large' | 'video_fps_unsupported' | 'video_fps_too_low' | 'video_aspect_unsupported' | 'video_duration_too_short' | 'video_duration_exceeds_max' | 'video_transform_failed' | 'media_fetch_failed' | 'document_format_unsupported' | 'document_too_large' | 'document_too_many_pages' | 'media_unsupported';
+                        message: string;
+                        hint?: string;
+                        allowed?: Array<string>;
+                        got?: string;
+                        /**
+                         * A short, friendly end-user line for `code` (render verbatim). `message` stays developer-grade; this is the display string. Size/limit codes interpolate the human cap/size.
+                         */
+                        display_error: string;
+                    } | null;
+                    source: {
+                        /**
+                         * MIME of the original, e.g. image/heic.
+                         */
+                        format: string;
+                        bytes: number;
+                        width: number | null;
+                        height: number | null;
+                        duration_ms: number | null;
+                    } | null;
+                    alt_text: string | null;
+                    per_platform: {
+                        [key: string]: {
+                            status: 'processing' | 'ready' | 'failed';
+                            /**
+                             * Public URL of this platform’s rendition (null until ready).
+                             */
+                            url: string | null;
+                            width: number | null;
+                            height: number | null;
+                            bytes: number | null;
+                            warnings: Array<{
+                                code?: unknown;
+                                message?: unknown;
+                                hint?: unknown;
+                                allowed?: unknown;
+                                got?: unknown;
+                                display_error?: unknown;
+                            }>;
+                            errors: Array<{
+                                code?: unknown;
+                                message?: unknown;
+                                hint?: unknown;
+                                allowed?: unknown;
+                                got?: unknown;
+                                display_error?: unknown;
+                            }>;
+                        };
+                    };
+                    external_id: string | null;
+                    /**
+                     * Customer-owned key/value context, returned on reads and filterable on list endpoints (exact match). Values are scalars: string (≤500 chars), number, or boolean. At most 50 keys; keys ≤40 chars; total serialized JSON must fit in 16 KiB. Arrays and nested objects are out of scope for v1 (kept out to keep the contract scalar + exact-match). Keep a key’s value type consistent across records — filtering matches type-exactly. Never derive auth/scopes from metadata.
+                     */
+                    metadata: {
+                        [key: string]: string | number | boolean;
+                    };
+                    /**
+                     * ISO-8601 creation time.
+                     */
+                    created_at: string;
+                    /**
+                     * ISO-8601 last-update time.
+                     */
+                    updated_at: string;
+                };
             }>;
         }>;
         /**