@23blocks/block-content 3.3.1 → 3.3.3

package/dist/index.esm.js

@@ -1,4 +1,4 @@
-import '@swc/helpers/_/_extends';
+import { _ } from '@swc/helpers/_/_extends';
 
 /**
  * Type guard for single resource document
@@ -162,7 +162,11 @@ const postMapper = {
             moderatedBy: parseString(resource.attributes['moderated_by']),
             moderatedAt: parseDate(resource.attributes['moderated_at']),
             moderationReason: parseString(resource.attributes['moderation_reason']),
-            moderationDecision: parseString(resource.attributes['moderation_decision'])
+            moderationDecision: parseString(resource.attributes['moderation_decision']),
+            // Series
+            seriesId: parseOptionalNumber(resource.attributes['series_id']),
+            seriesUniqueId: parseString(resource.attributes['series_unique_id']),
+            seriesSequence: parseOptionalNumber(resource.attributes['series_sequence'])
         })
 };
 
@@ -335,6 +339,115 @@ function createPostsService(transport, _config) {
     };
 }
 
+const postVersionMapper = {
+    type: 'PostVersion',
+    map: (resource)=>({
+            id: resource.id,
+            uniqueId: parseString(resource.attributes['unique_id']),
+            createdAt: parseDate(resource.attributes['created_at']) || new Date(),
+            updatedAt: parseDate(resource.attributes['updated_at']) || new Date(),
+            postUniqueId: parseString(resource.attributes['post_unique_id']) || '',
+            // Content
+            title: parseString(resource.attributes['title']) || '',
+            abstract: parseString(resource.attributes['abstract']),
+            keywords: parseString(resource.attributes['keywords']),
+            content: parseString(resource.attributes['content']),
+            // Media
+            thumbnailUrl: parseString(resource.attributes['thumbnail_url']),
+            imageUrl: parseString(resource.attributes['image_url']),
+            mediaUrl: parseString(resource.attributes['media_url']),
+            // Metadata
+            payload: resource.attributes['payload'],
+            status: parseStatus(resource.attributes['status']),
+            enabled: parseBoolean(resource.attributes['enabled']),
+            // Publishing
+            publishAt: parseDate(resource.attributes['publish_at']),
+            publishUntil: parseDate(resource.attributes['publish_until']),
+            // Author
+            userUniqueId: parseString(resource.attributes['user_unique_id']),
+            userName: parseString(resource.attributes['user_name']),
+            userAlias: parseString(resource.attributes['user_alias']),
+            userAvatarUrl: parseString(resource.attributes['user_avatar_url']),
+            // Visibility
+            isPublic: parseBoolean(resource.attributes['is_public']),
+            // Versioning
+            version: parseOptionalNumber(resource.attributes['version']),
+            revision: parseOptionalNumber(resource.attributes['revision']),
+            source: parseString(resource.attributes['source']),
+            // AI
+            aiGenerated: parseBoolean(resource.attributes['ai_generated']),
+            aiModel: parseString(resource.attributes['ai_model']),
+            // Moderation
+            moderated: parseBoolean(resource.attributes['moderated']),
+            moderatedBy: parseString(resource.attributes['moderated_by']),
+            moderatedAt: parseDate(resource.attributes['moderated_at']),
+            moderationReason: parseString(resource.attributes['moderation_reason']),
+            moderationDecision: parseString(resource.attributes['moderation_decision'])
+        })
+};
+
+function createPostVersionsService(transport, _config) {
+    return {
+        async list (postUniqueId, params) {
+            const queryParams = {};
+            if (params == null ? void 0 : params.page) queryParams['page'] = String(params.page);
+            if (params == null ? void 0 : params.perPage) queryParams['records'] = String(params.perPage);
+            if (params == null ? void 0 : params.status) queryParams['status'] = params.status;
+            // Note: The API may not have a dedicated versions list endpoint
+            // This uses the post_versions relationship from the post
+            const response = await transport.get(`/posts/${postUniqueId}`, {
+                params: _({}, queryParams, {
+                    include: 'post_versions'
+                })
+            });
+            // Extract versions from included relationships
+            const data = response;
+            if (data.included) {
+                const versions = data.included.filter((item)=>{
+                    const typed = item;
+                    return typed.type === 'PostVersion' || typed.type === 'post_version';
+                });
+                return {
+                    data: versions.map((v)=>postVersionMapper.map(v)),
+                    meta: {
+                        total: versions.length,
+                        page: 1,
+                        perPage: versions.length
+                    }
+                };
+            }
+            return {
+                data: [],
+                meta: {
+                    total: 0,
+                    page: 1,
+                    perPage: 10
+                }
+            };
+        },
+        async get (postUniqueId, versionUniqueId) {
+            // Get post with versions included and find the specific one
+            const response = await transport.get(`/posts/${postUniqueId}`, {
+                params: {
+                    include: 'post_versions'
+                }
+            });
+            const data = response;
+            if (data.included) {
+                const version = data.included.find((item)=>(item.type === 'PostVersion' || item.type === 'post_version') && (item.attributes['unique_id'] === versionUniqueId || item.id === versionUniqueId));
+                if (version) {
+                    return postVersionMapper.map(version);
+                }
+            }
+            throw new Error(`Version ${versionUniqueId} not found for post ${postUniqueId}`);
+        },
+        async publish (postUniqueId, versionUniqueId) {
+            const response = await transport.post(`/posts/${postUniqueId}/versions/${versionUniqueId}/publish`, {});
+            return decodeOne(response, postVersionMapper);
+        }
+    };
+}
+
 const commentMapper = {
     type: 'Comment',
     map: (resource)=>({
@@ -378,27 +491,25 @@ const commentMapper = {
 
 function createCommentsService(transport, _config) {
     return {
-        async list (params) {
+        async list (postUniqueId, params) {
             const queryParams = {};
             if (params == null ? void 0 : params.page) queryParams['page'] = String(params.page);
             if (params == null ? void 0 : params.perPage) queryParams['records'] = String(params.perPage);
-            if (params == null ? void 0 : params.postUniqueId) queryParams['post_unique_id'] = params.postUniqueId;
             if (params == null ? void 0 : params.userUniqueId) queryParams['user_unique_id'] = params.userUniqueId;
             if (params == null ? void 0 : params.parentId) queryParams['parent_id'] = params.parentId;
             if (params == null ? void 0 : params.status) queryParams['status'] = params.status;
-            const response = await transport.get('/comments', {
+            const response = await transport.get(`/posts/${postUniqueId}/comments`, {
                 params: queryParams
             });
             return decodePageResult(response, commentMapper);
         },
-        async get (uniqueId) {
-            const response = await transport.get(`/comments/${uniqueId}`);
+        async get (postUniqueId, uniqueId) {
+            const response = await transport.get(`/posts/${postUniqueId}/comments/${uniqueId}`);
             return decodeOne(response, commentMapper);
         },
-        async create (data) {
-            const response = await transport.post('/comments', {
+        async create (postUniqueId, data) {
+            const response = await transport.post(`/posts/${postUniqueId}/comments`, {
                 comment: {
-                    post_unique_id: data.postUniqueId,
                     content: data.content,
                     thumbnail_url: data.thumbnailUrl,
                     image_url: data.imageUrl,
@@ -410,8 +521,8 @@ function createCommentsService(transport, _config) {
             });
             return decodeOne(response, commentMapper);
         },
-        async update (uniqueId, data) {
-            const response = await transport.put(`/comments/${uniqueId}`, {
+        async update (postUniqueId, uniqueId, data) {
+            const response = await transport.put(`/posts/${postUniqueId}/comments/${uniqueId}`, {
                 comment: {
                     content: data.content,
                     thumbnail_url: data.thumbnailUrl,
@@ -425,47 +536,45 @@ function createCommentsService(transport, _config) {
             });
             return decodeOne(response, commentMapper);
         },
-        async delete (uniqueId) {
-            await transport.delete(`/comments/${uniqueId}`);
+        async delete (postUniqueId, uniqueId) {
+            await transport.delete(`/posts/${postUniqueId}/comments/${uniqueId}`);
         },
-        async reply (parentCommentUniqueId, data) {
-            const response = await transport.post('/comments', {
+        async reply (postUniqueId, parentCommentUniqueId, data) {
+            const response = await transport.post(`/posts/${postUniqueId}/comments/${parentCommentUniqueId}/reply`, {
                 comment: {
-                    post_unique_id: data.postUniqueId,
                     content: data.content,
                     thumbnail_url: data.thumbnailUrl,
                     image_url: data.imageUrl,
                     content_url: data.contentUrl,
                     media_url: data.mediaUrl,
-                    parent_id: parentCommentUniqueId,
                     payload: data.payload
                 }
             });
             return decodeOne(response, commentMapper);
         },
         // Engagement
-        async like (uniqueId) {
-            const response = await transport.post(`/comments/${uniqueId}/like`, {});
+        async like (postUniqueId, uniqueId) {
+            const response = await transport.put(`/posts/${postUniqueId}/comments/${uniqueId}/like`, {});
             return decodeOne(response, commentMapper);
         },
-        async dislike (uniqueId) {
-            const response = await transport.post(`/comments/${uniqueId}/dislike`, {});
+        async dislike (postUniqueId, uniqueId) {
+            const response = await transport.put(`/posts/${postUniqueId}/comments/${uniqueId}/dislike`, {});
             return decodeOne(response, commentMapper);
         },
-        async save (uniqueId) {
-            const response = await transport.put(`/comments/${uniqueId}/save`, {});
+        async save (postUniqueId, uniqueId) {
+            const response = await transport.put(`/posts/${postUniqueId}/comments/${uniqueId}/save`, {});
             return decodeOne(response, commentMapper);
         },
-        async unsave (uniqueId) {
-            const response = await transport.delete(`/comments/${uniqueId}/unsave`);
+        async unsave (postUniqueId, uniqueId) {
+            const response = await transport.delete(`/posts/${postUniqueId}/comments/${uniqueId}/unsave`);
             return decodeOne(response, commentMapper);
         },
-        async follow (uniqueId) {
-            const response = await transport.put(`/comments/${uniqueId}/follow`, {});
+        async follow (postUniqueId, uniqueId) {
+            const response = await transport.put(`/posts/${postUniqueId}/comments/${uniqueId}/follow`, {});
             return decodeOne(response, commentMapper);
         },
-        async unfollow (uniqueId) {
-            const response = await transport.delete(`/comments/${uniqueId}/unfollow`);
+        async unfollow (postUniqueId, uniqueId) {
+            const response = await transport.delete(`/posts/${postUniqueId}/comments/${uniqueId}/unfollow`);
             return decodeOne(response, commentMapper);
         }
     };
@@ -478,29 +587,19 @@ const categoryMapper = {
             uniqueId: parseString(resource.attributes['unique_id']),
             createdAt: parseDate(resource.attributes['created_at']) || new Date(),
             updatedAt: parseDate(resource.attributes['updated_at']) || new Date(),
-            code: parseString(resource.attributes['code']) || '',
+            // Core fields from API
+            code: parseString(resource.attributes['code']),
             name: parseString(resource.attributes['name']) || '',
             description: parseString(resource.attributes['description']),
+            // Hierarchy
             parentId: parseString(resource.attributes['parent_id']),
-            parentUniqueId: parseString(resource.attributes['parent_unique_id']),
             // Display
             displayOrder: parseOptionalNumber(resource.attributes['display_order']),
-            iconUrl: parseString(resource.attributes['icon_url']),
             imageUrl: parseString(resource.attributes['image_url']),
             contentUrl: parseString(resource.attributes['content_url']),
-            slug: parseString(resource.attributes['slug']),
             // Business Logic
             status: parseStatus(resource.attributes['status']),
             enabled: parseBoolean(resource.attributes['enabled']),
-            // SEO
-            metaTitle: parseString(resource.attributes['meta_title']),
-            metaDescription: parseString(resource.attributes['meta_description']),
-            metaKeywords: parseString(resource.attributes['meta_keywords']),
-            // Source
-            source: parseString(resource.attributes['source']),
-            sourceAlias: parseString(resource.attributes['source_alias']),
-            sourceId: parseString(resource.attributes['source_id']),
-            sourceType: parseString(resource.attributes['source_type']),
             // Extra
             payload: resource.attributes['payload'],
             postCount: parseOptionalNumber(resource.attributes['post_count'])
@@ -513,56 +612,34 @@ function createCategoriesService(transport, _config) {
             const queryParams = {};
             if (params == null ? void 0 : params.page) queryParams['page'] = String(params.page);
             if (params == null ? void 0 : params.perPage) queryParams['records'] = String(params.perPage);
-            if (params == null ? void 0 : params.parentUniqueId) queryParams['parent_unique_id'] = params.parentUniqueId;
+            if (params == null ? void 0 : params.parentId) queryParams['parent_id'] = params.parentId;
             if (params == null ? void 0 : params.withChildren) queryParams['with'] = 'children';
-            if (params == null ? void 0 : params.withPosts) queryParams['with'] = params.withChildren ? 'children,posts' : 'posts';
-            const response = await transport.get('/content/categories', {
+            if (params == null ? void 0 : params.withPosts) {
+                queryParams['with'] = params.withChildren ? 'children,posts' : 'posts';
+            }
+            const response = await transport.get('/categories', {
                 params: queryParams
             });
             return decodePageResult(response, categoryMapper);
         },
         async get (uniqueId) {
-            const response = await transport.get(`/content/categories/${uniqueId}`);
+            const response = await transport.get(`/categories/${uniqueId}`);
             return decodeOne(response, categoryMapper);
         },
         async create (data) {
-            const response = await transport.post('/content/categories', {
+            const response = await transport.post('/categories', {
                 category: {
+                    code: data.code,
                     name: data.name,
                     description: data.description,
-                    parent_unique_id: data.parentUniqueId,
-                    display_order: data.displayOrder,
-                    image_url: data.imageUrl,
-                    icon_url: data.iconUrl
-                }
-            });
-            return decodeOne(response, categoryMapper);
-        },
-        async update (uniqueId, data) {
-            const response = await transport.put(`/content/categories/${uniqueId}`, {
-                category: {
-                    name: data.name,
-                    description: data.description,
-                    parent_unique_id: data.parentUniqueId,
+                    parent_id: data.parentId,
                     display_order: data.displayOrder,
                     image_url: data.imageUrl,
-                    icon_url: data.iconUrl,
-                    enabled: data.enabled,
-                    status: data.status
+                    content_url: data.contentUrl,
+                    payload: data.payload
                 }
             });
             return decodeOne(response, categoryMapper);
-        },
-        async delete (uniqueId) {
-            await transport.delete(`/content/categories/${uniqueId}`);
-        },
-        async recover (uniqueId) {
-            const response = await transport.put(`/content/categories/${uniqueId}/recover`, {});
-            return decodeOne(response, categoryMapper);
-        },
-        async getChildren (uniqueId) {
-            const response = await transport.get(`/content/categories/${uniqueId}/children`);
-            return decodeMany(response, categoryMapper);
         }
     };
 }
@@ -637,26 +714,69 @@ function createTagsService(transport, _config) {
 }
 
 const contentUserMapper = {
-    type: 'user',
-    map: (data)=>{
-        var _data_id, _data_unique_id, _data_name, _data_email, _data_posts_count, _data_comments_count, _data_followers_count, _data_following_count, _data_status;
-        return {
-            id: String((_data_id = data['id']) != null ? _data_id : ''),
-            uniqueId: String((_data_unique_id = data['unique_id']) != null ? _data_unique_id : ''),
-            name: String((_data_name = data['name']) != null ? _data_name : ''),
-            email: String((_data_email = data['email']) != null ? _data_email : ''),
-            avatarUrl: data['avatar_url'],
-            bio: data['bio'],
-            postsCount: Number((_data_posts_count = data['posts_count']) != null ? _data_posts_count : 0),
-            commentsCount: Number((_data_comments_count = data['comments_count']) != null ? _data_comments_count : 0),
-            followersCount: Number((_data_followers_count = data['followers_count']) != null ? _data_followers_count : 0),
-            followingCount: Number((_data_following_count = data['following_count']) != null ? _data_following_count : 0),
-            status: (_data_status = data['status']) != null ? _data_status : 'active',
-            payload: data['payload'],
-            createdAt: data['created_at'] ? new Date(data['created_at']) : new Date(),
-            updatedAt: data['updated_at'] ? new Date(data['updated_at']) : new Date()
-        };
-    }
+    type: 'UserIdentity',
+    map: (resource)=>({
+            id: resource.id,
+            uniqueId: parseString(resource.attributes['unique_id']),
+            createdAt: parseDate(resource.attributes['created_at']) || new Date(),
+            updatedAt: parseDate(resource.attributes['updated_at']) || new Date(),
+            // Name fields
+            firstName: parseString(resource.attributes['first_name']),
+            lastName: parseString(resource.attributes['last_name']),
+            name: parseString(resource.attributes['user_name']) || parseString(resource.attributes['name']),
+            // Contact
+            email: parseString(resource.attributes['email']),
+            phone: parseString(resource.attributes['phone']),
+            // Identity references
+            userUniqueId: parseString(resource.attributes['user_unique_id']),
+            userName: parseString(resource.attributes['user_name']),
+            avatarUrl: parseString(resource.attributes['avatar_url']),
+            // Role
+            roleName: parseString(resource.attributes['role_name']),
+            roleUniqueId: parseString(resource.attributes['role_unique_id']),
+            // Preferences
+            timeZone: parseString(resource.attributes['time_zone']),
+            preferredLanguage: parseString(resource.attributes['preferred_language']),
+            // Integrations
+            stripeId: parseString(resource.attributes['stripe_id']),
+            walletCode: parseString(resource.attributes['wallet_code']),
+            // Notification preferences
+            emailNotifications: parseBoolean(resource.attributes['email_notifications']),
+            smsNotifications: parseBoolean(resource.attributes['sms_notifications']),
+            whatsappNotifications: parseBoolean(resource.attributes['whatsapp_notifications']),
+            otherNotifications: parseBoolean(resource.attributes['other_notifications']),
+            // Business logic
+            status: parseStatus(resource.attributes['status']),
+            payload: resource.attributes['payload'],
+            // Legacy/computed fields
+            bio: parseString(resource.attributes['bio']),
+            postsCount: parseOptionalNumber(resource.attributes['posts_count']),
+            commentsCount: parseOptionalNumber(resource.attributes['comments_count']),
+            followersCount: parseOptionalNumber(resource.attributes['followers_count']),
+            followingCount: parseOptionalNumber(resource.attributes['following_count'])
+        })
+};
+const followingMapper = {
+    type: 'Following',
+    map: (resource)=>({
+            id: resource.id,
+            uniqueId: parseString(resource.attributes['unique_id']),
+            createdAt: parseDate(resource.attributes['created_at']) || new Date(),
+            updatedAt: parseDate(resource.attributes['updated_at']) || new Date(),
+            // The user being followed
+            userUniqueId: parseString(resource.attributes['user_unique_id']) || '',
+            userName: parseString(resource.attributes['user_name']),
+            userAlias: parseString(resource.attributes['user_alias']),
+            userAvatarUrl: parseString(resource.attributes['user_avatar_url']),
+            // The follower
+            followerUniqueId: parseString(resource.attributes['follower_unique_id']) || '',
+            followerName: parseString(resource.attributes['follower_name']),
+            followerAlias: parseString(resource.attributes['follower_alias']),
+            followerAvatarUrl: parseString(resource.attributes['follower_avatar_url']),
+            // Metadata
+            followingSince: parseDate(resource.attributes['following_since']),
+            payload: resource.attributes['payload']
+        })
 };
 
 function createContentUsersService(transport, _config) {
@@ -681,8 +801,13 @@ function createContentUsersService(transport, _config) {
                 user: {
                     email: data.email,
                     name: data.name,
+                    first_name: data.firstName,
+                    last_name: data.lastName,
                     avatar_url: data.avatarUrl,
                     bio: data.bio,
+                    phone: data.phone,
+                    time_zone: data.timeZone,
+                    preferred_language: data.preferredLanguage,
                     payload: data.payload
                 }
             });
@@ -692,8 +817,17 @@ function createContentUsersService(transport, _config) {
             const response = await transport.put(`/identities/${uniqueId}`, {
                 user: {
                     name: data.name,
+                    first_name: data.firstName,
+                    last_name: data.lastName,
                     avatar_url: data.avatarUrl,
                     bio: data.bio,
+                    phone: data.phone,
+                    time_zone: data.timeZone,
+                    preferred_language: data.preferredLanguage,
+                    email_notifications: data.emailNotifications,
+                    sms_notifications: data.smsNotifications,
+                    whatsapp_notifications: data.whatsappNotifications,
+                    other_notifications: data.otherNotifications,
                     payload: data.payload
                 }
             });
@@ -739,11 +873,11 @@ function createContentUsersService(transport, _config) {
         },
         async getFollowers (uniqueId) {
             const response = await transport.get(`/identities/${uniqueId}/followers`);
-            return decodeMany(response, contentUserMapper);
+            return decodeMany(response, followingMapper);
         },
         async getFollowing (uniqueId) {
             const response = await transport.get(`/identities/${uniqueId}/following`);
-            return decodeMany(response, contentUserMapper);
+            return decodeMany(response, followingMapper);
         },
         async followUser (uniqueId, targetUserUniqueId) {
             await transport.post(`/identities/${uniqueId}/follows/${targetUserUniqueId}`, {});
@@ -926,15 +1060,180 @@ const activityMapper = {
     };
 }
 
+function parseVisibility(value) {
+    const str = parseString(value);
+    if (str === 'public' || str === 'private' || str === 'unlisted') {
+        return str;
+    }
+    return undefined;
+}
+function parseCompletionStatus(value) {
+    const str = parseString(value);
+    if (str === 'ongoing' || str === 'completed' || str === 'hiatus' || str === 'cancelled') {
+        return str;
+    }
+    return undefined;
+}
+const seriesMapper = {
+    type: 'Series',
+    map: (resource)=>({
+            id: resource.id,
+            uniqueId: parseString(resource.attributes['unique_id']),
+            createdAt: parseDate(resource.attributes['created_at']) || new Date(),
+            updatedAt: parseDate(resource.attributes['updated_at']) || new Date(),
+            title: parseString(resource.attributes['title']) || '',
+            description: parseString(resource.attributes['description']),
+            slug: parseString(resource.attributes['slug']),
+            thumbnailUrl: parseString(resource.attributes['thumbnail_url']),
+            imageUrl: parseString(resource.attributes['image_url']),
+            status: parseStatus(resource.attributes['status']),
+            enabled: parseBoolean(resource.attributes['enabled']),
+            visibility: parseVisibility(resource.attributes['visibility']),
+            completionStatus: parseCompletionStatus(resource.attributes['completion_status']),
+            // User
+            userUniqueId: parseString(resource.attributes['user_unique_id']),
+            userName: parseString(resource.attributes['user_name']),
+            userAlias: parseString(resource.attributes['user_alias']),
+            userAvatarUrl: parseString(resource.attributes['user_avatar_url']),
+            // Engagement
+            postsCount: parseOptionalNumber(resource.attributes['posts_count']),
+            likes: parseOptionalNumber(resource.attributes['likes']),
+            dislikes: parseOptionalNumber(resource.attributes['dislikes']),
+            followers: parseOptionalNumber(resource.attributes['followers']),
+            savers: parseOptionalNumber(resource.attributes['savers']),
+            // AI
+            aiGenerated: parseBoolean(resource.attributes['ai_generated']),
+            aiModel: parseString(resource.attributes['ai_model']),
+            // Moderation
+            moderated: parseBoolean(resource.attributes['moderated']),
+            // Metadata
+            payload: resource.attributes['payload']
+        })
+};
+
+function createSeriesService(transport, _config) {
+    return {
+        // CRUD Operations
+        async list (params) {
+            const queryParams = {};
+            if (params == null ? void 0 : params.page) queryParams['page'] = String(params.page);
+            if (params == null ? void 0 : params.perPage) queryParams['records'] = String(params.perPage);
+            const response = await transport.get('/series', {
+                params: queryParams
+            });
+            return decodePageResult(response, seriesMapper);
+        },
+        async query (params) {
+            const queryParams = {};
+            if (params == null ? void 0 : params.page) queryParams['page'] = String(params.page);
+            if (params == null ? void 0 : params.perPage) queryParams['records'] = String(params.perPage);
+            if (params == null ? void 0 : params.visibility) queryParams['visibility'] = params.visibility;
+            if (params == null ? void 0 : params.completionStatus) queryParams['completion_status'] = params.completionStatus;
+            if (params == null ? void 0 : params.search) queryParams['search'] = params.search;
+            if (params == null ? void 0 : params.userUniqueId) queryParams['user_unique_id'] = params.userUniqueId;
+            const response = await transport.post('/series/query', queryParams);
+            return decodePageResult(response, seriesMapper);
+        },
+        async get (uniqueId) {
+            const response = await transport.get(`/series/${uniqueId}`);
+            return decodeOne(response, seriesMapper);
+        },
+        async create (data) {
+            const response = await transport.post('/series', {
+                series: {
+                    title: data.title,
+                    description: data.description,
+                    slug: data.slug,
+                    thumbnail_url: data.thumbnailUrl,
+                    image_url: data.imageUrl,
+                    visibility: data.visibility,
+                    completion_status: data.completionStatus,
+                    payload: data.payload
+                }
+            });
+            return decodeOne(response, seriesMapper);
+        },
+        async update (uniqueId, data) {
+            const response = await transport.put(`/series/${uniqueId}`, {
+                series: {
+                    title: data.title,
+                    description: data.description,
+                    slug: data.slug,
+                    thumbnail_url: data.thumbnailUrl,
+                    image_url: data.imageUrl,
+                    visibility: data.visibility,
+                    completion_status: data.completionStatus,
+                    enabled: data.enabled,
+                    status: data.status,
+                    payload: data.payload
+                }
+            });
+            return decodeOne(response, seriesMapper);
+        },
+        async delete (uniqueId) {
+            await transport.delete(`/series/${uniqueId}`);
+        },
+        // Social Actions
+        async like (uniqueId) {
+            const response = await transport.put(`/series/${uniqueId}/like`, {});
+            return decodeOne(response, seriesMapper);
+        },
+        async dislike (uniqueId) {
+            const response = await transport.put(`/series/${uniqueId}/dislike`, {});
+            return decodeOne(response, seriesMapper);
+        },
+        async follow (uniqueId) {
+            const response = await transport.put(`/series/${uniqueId}/follow`, {});
+            return decodeOne(response, seriesMapper);
+        },
+        async unfollow (uniqueId) {
+            await transport.delete(`/series/${uniqueId}/unfollow`);
+        },
+        async save (uniqueId) {
+            const response = await transport.put(`/series/${uniqueId}/save`, {});
+            return decodeOne(response, seriesMapper);
+        },
+        async unsave (uniqueId) {
+            await transport.delete(`/series/${uniqueId}/unsave`);
+        },
+        // Post Management
+        async getPosts (uniqueId) {
+            const response = await transport.get(`/series/${uniqueId}/posts`);
+            return decodeMany(response, postMapper);
+        },
+        async addPost (seriesUniqueId, postUniqueId, sequence) {
+            const queryParams = {};
+            if (sequence !== undefined) queryParams['sequence'] = String(sequence);
+            await transport.post(`/series/${seriesUniqueId}/posts/${postUniqueId}`, {}, {
+                params: queryParams
+            });
+        },
+        async removePost (seriesUniqueId, postUniqueId) {
+            await transport.delete(`/series/${seriesUniqueId}/posts/${postUniqueId}`);
+        },
+        async reorderPosts (uniqueId, data) {
+            const response = await transport.put(`/series/${uniqueId}/reorder`, {
+                posts: data.posts.map((p)=>({
+                        post_unique_id: p.postUniqueId,
+                        sequence: p.sequence
+                    }))
+            });
+            return decodeOne(response, seriesMapper);
+        }
+    };
+}
+
 function createContentBlock(transport, config) {
     return {
         posts: createPostsService(transport),
+        postVersions: createPostVersionsService(transport),
         comments: createCommentsService(transport),
         categories: createCategoriesService(transport),
         tags: createTagsService(transport),
         users: createContentUsersService(transport),
         moderation: createModerationService(transport),
-        activity: createActivityService(transport)
+        activity: createActivityService(transport),
+        series: createSeriesService(transport)
     };
 }
 const contentBlockMetadata = {
@@ -943,13 +1242,16 @@ const contentBlockMetadata = {
     description: 'Content management for posts, comments, categories, tags, and users',
     resourceTypes: [
         'Post',
+        'PostVersion',
         'Comment',
         'Category',
         'Tag',
         'ContentUser',
+        'Following',
         'ContentFlag',
-        'Activity'
+        'Activity',
+        'Series'
     ]
 };
 
-export { activityMapper, categoryMapper, commentMapper, contentBlockMetadata, contentFlagMapper, contentUserMapper, createActivityService, createCategoriesService, createCommentsService, createContentBlock, createContentUsersService, createModerationService, createPostsService, createTagsService, postMapper, tagMapper };
+export { activityMapper, categoryMapper, commentMapper, contentBlockMetadata, contentFlagMapper, contentUserMapper, createActivityService, createCategoriesService, createCommentsService, createContentBlock, createContentUsersService, createModerationService, createPostVersionsService, createPostsService, createSeriesService, createTagsService, followingMapper, postMapper, postVersionMapper, seriesMapper, tagMapper };