@23blocks/block-content 1.0.3 → 1.0.5

package/dist/index.d.ts

@@ -0,0 +1 @@
+export * from "./src/index";

package/dist/index.esm.js

@@ -0,0 +1,601 @@
+import '@swc/helpers/_/_extends';
+
+/**
+ * Type guard for single resource document
+ */ function isSingleResourceDocument(doc) {
+    return doc.data !== null && doc.data !== undefined && !Array.isArray(doc.data);
+}
+/**
+ * Type guard for collection resource document
+ */ function isCollectionDocument(doc) {
+    return Array.isArray(doc.data);
+}
+/**
+ * Create a key for the included map
+ */ function resourceKey(type, id) {
+    return `${type}:${id}`;
+}
+/**
+ * Build an included map from an array of resources
+ */ function buildIncludedMap(included = []) {
+    const map = new Map();
+    for (const resource of included){
+        map.set(resourceKey(resource.type, resource.id), resource);
+    }
+    return map;
+}
+/**
+ * Decode a single resource from a JSON:API document
+ */ function decodeOne(document, mapper) {
+    if (!isSingleResourceDocument(document)) {
+        throw new Error('Expected single resource document');
+    }
+    const included = buildIncludedMap(document.included);
+    return mapper.map(document.data, included);
+}
+/**
+ * Decode multiple resources from a JSON:API document
+ */ function decodeMany(document, mapper) {
+    if (!isCollectionDocument(document)) {
+        throw new Error('Expected collection document');
+    }
+    const included = buildIncludedMap(document.included);
+    return document.data.map((resource)=>mapper.map(resource, included));
+}
+/**
+ * Extract pagination metadata from JSON:API meta
+ */ function extractPageMeta(meta) {
+    var _meta_current_page, _meta_total_pages, _meta_total_count, _meta_per_page;
+    return {
+        currentPage: (_meta_current_page = meta == null ? void 0 : meta.current_page) != null ? _meta_current_page : 1,
+        totalPages: (_meta_total_pages = meta == null ? void 0 : meta.total_pages) != null ? _meta_total_pages : 1,
+        totalCount: (_meta_total_count = meta == null ? void 0 : meta.total_count) != null ? _meta_total_count : 0,
+        perPage: (_meta_per_page = meta == null ? void 0 : meta.per_page) != null ? _meta_per_page : 0
+    };
+}
+/**
+ * Decode a paginated collection from a JSON:API document
+ */ function decodePageResult(document, mapper) {
+    const data = isCollectionDocument(document) ? decodeMany(document, mapper) : [];
+    return {
+        data,
+        meta: extractPageMeta(document.meta)
+    };
+}
+
+/**
+ * Parse a string value, returning undefined for empty/undefined
+ */ function parseString(value) {
+    if (value === null || value === undefined) {
+        return undefined;
+    }
+    const str = String(value);
+    return str.length > 0 ? str : undefined;
+}
+/**
+ * Parse a date value
+ */ function parseDate(value) {
+    if (value === null || value === undefined) {
+        return undefined;
+    }
+    if (value instanceof Date) {
+        return value;
+    }
+    if (typeof value === 'string' || typeof value === 'number') {
+        const date = new Date(value);
+        return isNaN(date.getTime()) ? undefined : date;
+    }
+    return undefined;
+}
+/**
+ * Parse a boolean value
+ */ function parseBoolean(value) {
+    if (typeof value === 'boolean') {
+        return value;
+    }
+    if (value === 'true' || value === '1' || value === 1) {
+        return true;
+    }
+    return false;
+}
+/**
+ * Parse an optional number value
+ */ function parseOptionalNumber(value) {
+    if (value === null || value === undefined) {
+        return undefined;
+    }
+    const num = Number(value);
+    return isNaN(num) ? undefined : num;
+}
+/**
+ * Parse entity status
+ */ function parseStatus(value) {
+    const status = parseString(value);
+    if (status === 'active' || status === 'inactive' || status === 'pending' || status === 'archived' || status === 'deleted') {
+        return status;
+    }
+    return 'active';
+}
+
+const postMapper = {
+    type: 'Post',
+    map: (resource)=>({
+            id: resource.id,
+            uniqueId: parseString(resource.attributes['unique_id']) || resource.id,
+            createdAt: parseDate(resource.attributes['created_at']) || new Date(),
+            updatedAt: parseDate(resource.attributes['updated_at']) || new Date(),
+            postVersionUniqueId: parseString(resource.attributes['post_version_unique_id']),
+            title: parseString(resource.attributes['title']) || '',
+            abstract: parseString(resource.attributes['abstract']),
+            keywords: parseString(resource.attributes['keywords']),
+            content: parseString(resource.attributes['content']),
+            thumbnailUrl: parseString(resource.attributes['thumbnail_url']),
+            imageUrl: parseString(resource.attributes['image_url']),
+            mediaUrl: parseString(resource.attributes['media_url']),
+            payload: resource.attributes['payload'],
+            status: parseStatus(resource.attributes['status']),
+            enabled: parseBoolean(resource.attributes['enabled']),
+            publishAt: parseDate(resource.attributes['publish_at']),
+            publishUntil: parseDate(resource.attributes['publish_until']),
+            // 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']),
+            // Visibility
+            isPublic: parseBoolean(resource.attributes['is_public']),
+            // Versioning
+            version: parseOptionalNumber(resource.attributes['version']),
+            // Engagement
+            likes: parseOptionalNumber(resource.attributes['likes']),
+            dislikes: parseOptionalNumber(resource.attributes['dislikes']),
+            comments: parseOptionalNumber(resource.attributes['comments']),
+            followers: parseOptionalNumber(resource.attributes['followers']),
+            savers: parseOptionalNumber(resource.attributes['savers']),
+            // SEO
+            slug: parseString(resource.attributes['slug']),
+            // 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 createPostsService(transport, _config) {
+    return {
+        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);
+            if (params == null ? void 0 : params.status) queryParams['status'] = params.status;
+            if (params == null ? void 0 : params.categoryUniqueId) queryParams['category_unique_id'] = params.categoryUniqueId;
+            if (params == null ? void 0 : params.tagUniqueId) queryParams['tag_unique_id'] = params.tagUniqueId;
+            if (params == null ? void 0 : params.userUniqueId) queryParams['user_unique_id'] = params.userUniqueId;
+            if (params == null ? void 0 : params.search) queryParams['search'] = params.search;
+            if ((params == null ? void 0 : params.isPublic) !== undefined) queryParams['is_public'] = String(params.isPublic);
+            if (params == null ? void 0 : params.withComments) queryParams['with'] = 'comments';
+            if (params == null ? void 0 : params.withCategories) queryParams['with'] = params.withComments ? 'comments,categories' : 'categories';
+            if (params == null ? void 0 : params.withTags) {
+                queryParams['with'] = queryParams['with'] ? `${queryParams['with']},tags` : 'tags';
+            }
+            if (params == null ? void 0 : params.sortBy) queryParams['sort'] = params.sortOrder === 'desc' ? `-${params.sortBy}` : params.sortBy;
+            const response = await transport.get('/posts', {
+                params: queryParams
+            });
+            return decodePageResult(response, postMapper);
+        },
+        async get (uniqueId) {
+            const response = await transport.get(`/posts/${uniqueId}`);
+            return decodeOne(response, postMapper);
+        },
+        async create (data) {
+            const response = await transport.post('/posts', {
+                data: {
+                    type: 'Post',
+                    attributes: {
+                        title: data.title,
+                        abstract: data.abstract,
+                        keywords: data.keywords,
+                        content: data.content,
+                        thumbnail_url: data.thumbnailUrl,
+                        image_url: data.imageUrl,
+                        media_url: data.mediaUrl,
+                        category_unique_ids: data.categoryUniqueIds,
+                        tag_unique_ids: data.tagUniqueIds,
+                        is_public: data.isPublic,
+                        publish_at: data.publishAt,
+                        publish_until: data.publishUntil,
+                        payload: data.payload
+                    }
+                }
+            });
+            return decodeOne(response, postMapper);
+        },
+        async update (uniqueId, data) {
+            const response = await transport.put(`/posts/${uniqueId}`, {
+                data: {
+                    type: 'Post',
+                    attributes: {
+                        title: data.title,
+                        abstract: data.abstract,
+                        keywords: data.keywords,
+                        content: data.content,
+                        thumbnail_url: data.thumbnailUrl,
+                        image_url: data.imageUrl,
+                        media_url: data.mediaUrl,
+                        category_unique_ids: data.categoryUniqueIds,
+                        tag_unique_ids: data.tagUniqueIds,
+                        is_public: data.isPublic,
+                        publish_at: data.publishAt,
+                        publish_until: data.publishUntil,
+                        enabled: data.enabled,
+                        status: data.status,
+                        payload: data.payload
+                    }
+                }
+            });
+            return decodeOne(response, postMapper);
+        },
+        async delete (uniqueId) {
+            await transport.delete(`/posts/${uniqueId}`);
+        },
+        async recover (uniqueId) {
+            const response = await transport.put(`/posts/${uniqueId}/recover`, {});
+            return decodeOne(response, postMapper);
+        },
+        async search (query, params) {
+            const queryParams = {
+                search: query
+            };
+            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.post('/posts/search', {
+                search: query
+            }, {
+                params: queryParams
+            });
+            return decodePageResult(response, postMapper);
+        },
+        async listDeleted (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('/posts/trash/show', {
+                params: queryParams
+            });
+            return decodePageResult(response, postMapper);
+        },
+        // Engagement
+        async like (uniqueId) {
+            const response = await transport.post(`/posts/${uniqueId}/like`, {});
+            return decodeOne(response, postMapper);
+        },
+        async dislike (uniqueId) {
+            const response = await transport.post(`/posts/${uniqueId}/dislike`, {});
+            return decodeOne(response, postMapper);
+        },
+        async save (uniqueId) {
+            const response = await transport.post(`/posts/${uniqueId}/save`, {});
+            return decodeOne(response, postMapper);
+        },
+        async follow (uniqueId) {
+            const response = await transport.post(`/posts/${uniqueId}/follow`, {});
+            return decodeOne(response, postMapper);
+        }
+    };
+}
+
+const commentMapper = {
+    type: 'Comment',
+    map: (resource)=>({
+            id: resource.id,
+            uniqueId: parseString(resource.attributes['unique_id']) || resource.id,
+            createdAt: parseDate(resource.attributes['created_at']) || new Date(),
+            updatedAt: parseDate(resource.attributes['updated_at']) || new Date(),
+            postUniqueId: parseString(resource.attributes['post_unique_id']) || '',
+            postVersion: parseOptionalNumber(resource.attributes['post_version']),
+            content: parseString(resource.attributes['content']) || '',
+            thumbnailUrl: parseString(resource.attributes['thumbnail_url']),
+            imageUrl: parseString(resource.attributes['image_url']),
+            contentUrl: parseString(resource.attributes['content_url']),
+            mediaUrl: parseString(resource.attributes['media_url']),
+            // 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']),
+            payload: resource.attributes['payload'],
+            status: parseStatus(resource.attributes['status']),
+            enabled: parseBoolean(resource.attributes['enabled']),
+            // Threading
+            parentId: parseString(resource.attributes['parent_id']),
+            // Engagement
+            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']),
+            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 createCommentsService(transport, _config) {
+    return {
+        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);
+            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', {
+                params: queryParams
+            });
+            return decodePageResult(response, commentMapper);
+        },
+        async get (uniqueId) {
+            const response = await transport.get(`/comments/${uniqueId}`);
+            return decodeOne(response, commentMapper);
+        },
+        async create (data) {
+            const response = await transport.post('/comments', {
+                data: {
+                    type: 'Comment',
+                    attributes: {
+                        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: data.parentId,
+                        payload: data.payload
+                    }
+                }
+            });
+            return decodeOne(response, commentMapper);
+        },
+        async update (uniqueId, data) {
+            const response = await transport.put(`/comments/${uniqueId}`, {
+                data: {
+                    type: 'Comment',
+                    attributes: {
+                        content: data.content,
+                        thumbnail_url: data.thumbnailUrl,
+                        image_url: data.imageUrl,
+                        content_url: data.contentUrl,
+                        media_url: data.mediaUrl,
+                        enabled: data.enabled,
+                        status: data.status,
+                        payload: data.payload
+                    }
+                }
+            });
+            return decodeOne(response, commentMapper);
+        },
+        async delete (uniqueId) {
+            await transport.delete(`/comments/${uniqueId}`);
+        },
+        // Engagement
+        async like (uniqueId) {
+            const response = await transport.post(`/comments/${uniqueId}/like`, {});
+            return decodeOne(response, commentMapper);
+        },
+        async dislike (uniqueId) {
+            const response = await transport.post(`/comments/${uniqueId}/dislike`, {});
+            return decodeOne(response, commentMapper);
+        }
+    };
+}
+
+const categoryMapper = {
+    type: 'Category',
+    map: (resource)=>({
+            id: resource.id,
+            uniqueId: parseString(resource.attributes['unique_id']) || resource.id,
+            createdAt: parseDate(resource.attributes['created_at']) || new Date(),
+            updatedAt: parseDate(resource.attributes['updated_at']) || new Date(),
+            code: parseString(resource.attributes['code']) || '',
+            name: parseString(resource.attributes['name']) || '',
+            description: parseString(resource.attributes['description']),
+            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'])
+        })
+};
+
+function createCategoriesService(transport, _config) {
+    return {
+        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);
+            if (params == null ? void 0 : params.parentUniqueId) queryParams['parent_unique_id'] = params.parentUniqueId;
+            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', {
+                params: queryParams
+            });
+            return decodePageResult(response, categoryMapper);
+        },
+        async get (uniqueId) {
+            const response = await transport.get(`/content/categories/${uniqueId}`);
+            return decodeOne(response, categoryMapper);
+        },
+        async create (data) {
+            const response = await transport.post('/content/categories', {
+                data: {
+                    type: 'Category',
+                    attributes: {
+                        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}`, {
+                data: {
+                    type: 'Category',
+                    attributes: {
+                        name: data.name,
+                        description: data.description,
+                        parent_unique_id: data.parentUniqueId,
+                        display_order: data.displayOrder,
+                        image_url: data.imageUrl,
+                        icon_url: data.iconUrl,
+                        enabled: data.enabled,
+                        status: data.status
+                    }
+                }
+            });
+            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);
+        }
+    };
+}
+
+const tagMapper = {
+    type: 'Tag',
+    map: (resource)=>({
+            id: resource.id,
+            uniqueId: parseString(resource.attributes['unique_id']) || resource.id,
+            createdAt: parseDate(resource.attributes['created_at']) || new Date(),
+            updatedAt: parseDate(resource.attributes['updated_at']) || new Date(),
+            tag: parseString(resource.attributes['tag']) || '',
+            thumbnailUrl: parseString(resource.attributes['thumbnail_url']),
+            imageUrl: parseString(resource.attributes['image_url']),
+            contentUrl: parseString(resource.attributes['content_url']),
+            mediaUrl: parseString(resource.attributes['media_url']),
+            payload: resource.attributes['payload'],
+            status: parseStatus(resource.attributes['status']),
+            enabled: parseBoolean(resource.attributes['enabled']),
+            slug: parseString(resource.attributes['slug'])
+        })
+};
+
+function createTagsService(transport, _config) {
+    return {
+        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);
+            if (params == null ? void 0 : params.search) queryParams['search'] = params.search;
+            const response = await transport.get('/tags', {
+                params: queryParams
+            });
+            return decodePageResult(response, tagMapper);
+        },
+        async get (uniqueId) {
+            const response = await transport.get(`/tags/${uniqueId}`);
+            return decodeOne(response, tagMapper);
+        },
+        async create (data) {
+            const response = await transport.post('/tags', {
+                data: {
+                    type: 'Tag',
+                    attributes: {
+                        tag: data.tag,
+                        thumbnail_url: data.thumbnailUrl,
+                        image_url: data.imageUrl,
+                        content_url: data.contentUrl,
+                        media_url: data.mediaUrl,
+                        payload: data.payload
+                    }
+                }
+            });
+            return decodeOne(response, tagMapper);
+        },
+        async update (uniqueId, data) {
+            const response = await transport.put(`/tags/${uniqueId}`, {
+                data: {
+                    type: 'Tag',
+                    attributes: {
+                        tag: data.tag,
+                        thumbnail_url: data.thumbnailUrl,
+                        image_url: data.imageUrl,
+                        content_url: data.contentUrl,
+                        media_url: data.mediaUrl,
+                        enabled: data.enabled,
+                        status: data.status,
+                        payload: data.payload
+                    }
+                }
+            });
+            return decodeOne(response, tagMapper);
+        },
+        async delete (uniqueId) {
+            await transport.delete(`/tags/${uniqueId}`);
+        }
+    };
+}
+
+function createContentBlock(transport, config) {
+    return {
+        posts: createPostsService(transport),
+        comments: createCommentsService(transport),
+        categories: createCategoriesService(transport),
+        tags: createTagsService(transport)
+    };
+}
+const contentBlockMetadata = {
+    name: 'content',
+    version: '0.1.0',
+    description: 'Content management for posts, comments, categories, and tags',
+    resourceTypes: [
+        'Post',
+        'Comment',
+        'Category',
+        'Tag'
+    ]
+};
+
+export { categoryMapper, commentMapper, contentBlockMetadata, createCategoriesService, createCommentsService, createContentBlock, createPostsService, createTagsService, postMapper, tagMapper };

package/dist/src/index.d.ts

@@ -0,0 +1,7 @@
+export { createContentBlock, contentBlockMetadata } from './lib/content.block';
+export type { ContentBlock, ContentBlockConfig } from './lib/content.block';
+export type { Post, CreatePostRequest, UpdatePostRequest, ListPostsParams, Comment, CreateCommentRequest, UpdateCommentRequest, ListCommentsParams, Category, CreateCategoryRequest, UpdateCategoryRequest, ListCategoriesParams, Tag, CreateTagRequest, UpdateTagRequest, ListTagsParams, } from './lib/types';
+export type { PostsService, CommentsService, CategoriesService, TagsService, } from './lib/services';
+export { createPostsService, createCommentsService, createCategoriesService, createTagsService, } from './lib/services';
+export { postMapper, commentMapper, categoryMapper, tagMapper, } from './lib/mappers';
+//# sourceMappingURL=index.d.ts.map

package/dist/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,kBAAkB,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAC/E,YAAY,EAAE,YAAY,EAAE,kBAAkB,EAAE,MAAM,qBAAqB,CAAC;AAG5E,YAAY,EAEV,IAAI,EACJ,iBAAiB,EACjB,iBAAiB,EACjB,eAAe,EAEf,OAAO,EACP,oBAAoB,EACpB,oBAAoB,EACpB,kBAAkB,EAElB,QAAQ,EACR,qBAAqB,EACrB,qBAAqB,EACrB,oBAAoB,EAEpB,GAAG,EACH,gBAAgB,EAChB,gBAAgB,EAChB,cAAc,GACf,MAAM,aAAa,CAAC;AAGrB,YAAY,EACV,YAAY,EACZ,eAAe,EACf,iBAAiB,EACjB,WAAW,GACZ,MAAM,gBAAgB,CAAC;AAExB,OAAO,EACL,kBAAkB,EAClB,qBAAqB,EACrB,uBAAuB,EACvB,iBAAiB,GAClB,MAAM,gBAAgB,CAAC;AAGxB,OAAO,EACL,UAAU,EACV,aAAa,EACb,cAAc,EACd,SAAS,GACV,MAAM,eAAe,CAAC"}

package/dist/src/lib/block-content.d.ts

@@ -0,0 +1,2 @@
+export declare function blockContent(): string;
+//# sourceMappingURL=block-content.d.ts.map

package/dist/src/lib/block-content.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"block-content.d.ts","sourceRoot":"","sources":["../../../src/lib/block-content.ts"],"names":[],"mappings":"AAAA,wBAAgB,YAAY,IAAI,MAAM,CAErC"}

package/dist/src/lib/content.block.d.ts

@@ -0,0 +1,15 @@
+import type { Transport, BlockConfig, BlockMetadata } from '@23blocks/contracts';
+import { type PostsService, type CommentsService, type CategoriesService, type TagsService } from './services';
+export interface ContentBlockConfig extends BlockConfig {
+    appId: string;
+    tenantId?: string;
+}
+export interface ContentBlock {
+    posts: PostsService;
+    comments: CommentsService;
+    categories: CategoriesService;
+    tags: TagsService;
+}
+export declare function createContentBlock(transport: Transport, config: ContentBlockConfig): ContentBlock;
+export declare const contentBlockMetadata: BlockMetadata;
+//# sourceMappingURL=content.block.d.ts.map

package/dist/src/lib/content.block.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"content.block.d.ts","sourceRoot":"","sources":["../../../src/lib/content.block.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,WAAW,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACjF,OAAO,EAKL,KAAK,YAAY,EACjB,KAAK,eAAe,EACpB,KAAK,iBAAiB,EACtB,KAAK,WAAW,EACjB,MAAM,YAAY,CAAC;AAEpB,MAAM,WAAW,kBAAmB,SAAQ,WAAW;IACrD,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,YAAY;IAC3B,KAAK,EAAE,YAAY,CAAC;IACpB,QAAQ,EAAE,eAAe,CAAC;IAC1B,UAAU,EAAE,iBAAiB,CAAC;IAC9B,IAAI,EAAE,WAAW,CAAC;CACnB;AAED,wBAAgB,kBAAkB,CAChC,SAAS,EAAE,SAAS,EACpB,MAAM,EAAE,kBAAkB,GACzB,YAAY,CAOd;AAED,eAAO,MAAM,oBAAoB,EAAE,aAUlC,CAAC"}

package/dist/src/lib/mappers/category.mapper.d.ts

@@ -0,0 +1,4 @@
+import type { ResourceMapper } from '@23blocks/jsonapi-codec';
+import type { Category } from '../types/category';
+export declare const categoryMapper: ResourceMapper<Category>;
+//# sourceMappingURL=category.mapper.d.ts.map

package/dist/src/lib/mappers/category.mapper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"category.mapper.d.ts","sourceRoot":"","sources":["../../../../src/lib/mappers/category.mapper.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAC;AAC9D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAGlD,eAAO,MAAM,cAAc,EAAE,cAAc,CAAC,QAAQ,CAwCnD,CAAC"}

package/dist/src/lib/mappers/comment.mapper.d.ts

@@ -0,0 +1,4 @@
+import type { ResourceMapper } from '@23blocks/jsonapi-codec';
+import type { Comment } from '../types/comment';
+export declare const commentMapper: ResourceMapper<Comment>;
+//# sourceMappingURL=comment.mapper.d.ts.map

package/dist/src/lib/mappers/comment.mapper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"comment.mapper.d.ts","sourceRoot":"","sources":["../../../../src/lib/mappers/comment.mapper.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAC;AAC9D,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAC;AAGhD,eAAO,MAAM,aAAa,EAAE,cAAc,CAAC,OAAO,CA8CjD,CAAC"}

package/dist/{lib/mappers/index.js → src/lib/mappers/index.d.ts}

@@ -2,5 +2,4 @@ export * from './post.mapper';
 export * from './comment.mapper';
 export * from './category.mapper';
 export * from './tag.mapper';
-
-//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.d.ts.map