2.1.0

feat(syncedinstance): Add SyncedInstance for multi-instance content synchronization, export it, add tests, and expand README
2.0.0
2025-10-08 09:57:59 +00:00 · 2025-10-08 09:57:59 +00:00 · 2025-10-08 09:14:46 +00:00 · 2025-10-08 09:14:45 +00:00 · 2025-10-07 14:31:54 +00:00 · 2025-10-07 14:31:54 +00:00
21 changed files with 2063 additions and 353 deletions
--- a/changelog.md
+++ b/changelog.md
@@ -1,5 +1,50 @@
 # Changelog

+## 2025-10-08 - 2.1.0 - feat(syncedinstance)
+Add SyncedInstance for multi-instance content synchronization, export it, add tests, and expand README
+
+- Introduce SyncedInstance class (ts/classes.syncedinstance.ts) to synchronize tags, posts and pages across Ghost instances with mapping and history support. New APIs: syncTags, syncPosts, syncPages, syncAll, getSyncStatus, clearSyncHistory, clearMappings.
+- Export SyncedInstance from the package entry point (ts/index.ts).
+- Add integration tests for SyncedInstance (test/test.syncedinstance.node.ts).
+- Expand README (readme.md) with Quick Start, detailed Multi-Instance Synchronization docs, examples and updated API reference.
+
+## 2025-10-08 - 2.0.0 - BREAKING CHANGE(classes.ghost)
+Remove Settings and Webhooks browse/read APIs, remove noisy console.error logs, and update tests/docs
+
+- Removed Settings API methods from Ghost: getSettings and updateSettings (breaking change).
+- Removed Webhooks browsing/reading methods from Ghost: getWebhooks and getWebhookById. createWebhook, updateWebhook and deleteWebhook remain.
+- Removed test/test.settings.node.ts and simplified test/test.webhook.node.ts to only exercise create/update/delete webhook flows without feature-availability guarding.
+- Stripped console.error debug logging across multiple classes (Author, Ghost, Member, Page, Post, Tag) to reduce noisy runtime output.
+- Updated README: removed 'Site Settings' section and clarified webhook API limitations supported by the underlying Ghost Admin SDK.
+
+## 2025-10-07 - 1.4.1 - fix(tests)
+Remove updated_at from post and page update test payloads
+
+- Stop setting updated_at in test update payloads to avoid mutating server-managed timestamps
+- Changed test/test.post.node.ts: removed updated_at assignment when updating a post
+- Changed test/test.page.node.ts: removed updated_at assignment when updating a page
+
+## 2025-10-07 - 1.4.0 - feat(classes.ghost)
+Add members, settings and webhooks support; implement Member class and add tests
+
+- Introduce IMember and Member class (ts/classes.member.ts) with CRUD (update, delete) and JSON helpers
+- Add member management API to Ghost: getMembers (with minimatch filtering), getMemberById, getMemberByEmail, createMember
+- Add site settings API to Ghost: getSettings and updateSettings (admin API wrappers)
+- Add webhooks management to Ghost: getWebhooks, getWebhookById, createWebhook, updateWebhook, deleteWebhook
+- Wire smartmatch filtering for members using @push.rocks/smartmatch
+- Export Member from ts/index.ts so it's part of the public API
+- Add comprehensive node tests for Ghost, Author, Member, Page, Post, Tag, Settings and Webhooks (test/*.node.ts)
+- Fix Post construction usages in classes.ghost to pass the Ghost instance when creating Post objects
+
+## 2025-10-07 - 1.3.0 - feat(core)
+Add Ghost CMS API client classes and README documentation
+
+- Implemented core TypeScript classes: Ghost, Post, Tag, Author and Page with CRUD methods and helpers
+- Added TypeScript interfaces for posts, tags, authors and pages to provide typings
+- Included comprehensive README with installation, usage examples and API method documentation
+- Added unit test scaffold under test/test.ts
+- Updated package metadata and commitinfo (version 1.2.0)
+
 ## 2025-10-07 - 1.2.0 - feat(ghost)
 Implement Tag, Author and Page models; add advanced filtering, search, bulk operations, image upload, related-posts, update tests and bump dependencies

--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
  "name": "@apiclient.xyz/ghost",
-  "version": "1.2.0",
+  "version": "2.1.0",
  "private": false,
  "description": "An unofficial Ghost CMS API package enabling content and admin functionality for managing posts.",
  "main": "dist_ts/index.js",
--- a/readme.md
+++ b/readme.md
@@ -1,458 +1,662 @@
-# @apiclient.xyz/ghost
-An unofficial Ghost API package
+# @apiclient.xyz/ghost 👻

-## Install
-To install the @apiclient.xyz/ghost package, you can use npm or yarn. Make sure you're using a package manager that supports ESM and TypeScript.
+> The **unofficial** TypeScript-first Ghost CMS API client that actually makes sense
+
+A modern, fully-typed API client for Ghost CMS that wraps both the Content and Admin APIs into an elegant, developer-friendly interface. Built with TypeScript, designed for humans.
+
+## 🚀 Why This Library?
+
+- **🎯 TypeScript Native** - Full type safety for all Ghost API operations
+- **🔥 Dual API Support** - Unified interface for both Content and Admin APIs
+- **⚡ Modern Async/Await** - No callback hell, just clean promises
+- **🎨 Elegant API** - Intuitive methods that match your mental model
+- **🔍 Smart Filtering** - Built-in minimatch support for flexible queries
+- **🔄 Multi-Instance Sync** - Synchronize content across multiple Ghost sites
+- **💪 Production Ready** - Battle-tested with comprehensive error handling
+
+## 📦 Installation

-NPM:
 ```bash
 npm install @apiclient.xyz/ghost
 ```

-Yarn:
+Or with pnpm:
+
 ```bash
-yarn add @apiclient.xyz/ghost
+pnpm install @apiclient.xyz/ghost
 ```

-## Usage
-
-Below is a detailed guide on how to use the `@apiclient.xyz/ghost` package in your TypeScript projects. We will cover everything from initialization to advanced usage scenarios.
-
-### Initialization
-
-First, you need to import the necessary classes and initialize the Ghost instance with the required API keys.
+## 🎯 Quick Start

 ```typescript
 import { Ghost } from '@apiclient.xyz/ghost';

-// Initialize the Ghost instance
-const ghostInstance = new Ghost({
-  baseUrl: 'https://your-ghost-url.com',
-  contentApiKey: 'your-content-api-key',
-  adminApiKey: 'your-admin-api-key'
+const ghost = new Ghost({
+  baseUrl: 'https://your-ghost-site.com',
+  contentApiKey: 'your_content_api_key',
+  adminApiKey: 'your_admin_api_key'
+});
+
+const posts = await ghost.getPosts();
+posts.forEach(post => console.log(post.getTitle()));
+```
+
+That's it. No complicated setup, no boilerplate. Just pure Ghost API goodness.
+
+## 📚 Core API
+
+### 🔑 Authentication & Setup
+
+Initialize the Ghost client with your API credentials:
+
+```typescript
+const ghost = new Ghost({
+  baseUrl: 'https://your-ghost-site.com',
+  contentApiKey: 'your_content_api_key',  // For reading public content
+  adminApiKey: 'your_admin_api_key'       // For write operations
 });
 ```

-### Basic Usage
+## 📝 Posts

-#### Fetching Posts
-
-You can fetch posts with the following method. This will give you an array of `Post` instances.
+### Get All Posts

 ```typescript
-// Fetch all posts
-const posts = await ghostInstance.getPosts();
+const posts = await ghost.getPosts();

-// Print titles of all posts
 posts.forEach(post => {
  console.log(post.getTitle());
+  console.log(post.getExcerpt());
+  console.log(post.getFeatureImage());
 });
 ```

-#### Fetching a Single Post by ID
-
-To fetch a single post by its ID:
+### Filter Posts

 ```typescript
-const postId = 'your-post-id';
-const post = await ghostInstance.getPostById(postId);
+const techPosts = await ghost.getPosts({ 
+  tag: 'technology',
+  limit: 10 
+});

+const featuredPosts = await ghost.getPosts({ 
+  featured: true,
+  limit: 5 
+});
+
+const authorPosts = await ghost.getPosts({ 
+  author: 'john-doe' 
+});
+```
+
+### Get Single Post
+
+```typescript
+const post = await ghost.getPostById('post-id');
 console.log(post.getTitle());
 console.log(post.getHtml());
+console.log(post.getAuthor());
 ```

-### Post Class Methods
-
-The `Post` class has several methods that can be useful for different scenarios.
-
-#### Getting Post Data
-
-These methods allow you to retrieve various parts of the post data.
+### Create Post

 ```typescript
-const postId = post.getId();
-const postTitle = post.getTitle();
-const postHtml = post.getHtml();
-const postExcerpt = post.getExcerpt();
-const postFeatureImage = post.getFeatureImage();
-
-console.log(`ID: ${postId}`);
-console.log(`Title: ${postTitle}`);
-console.log(`HTML: ${postHtml}`);
-console.log(`Excerpt: ${postExcerpt}`);
-console.log(`Feature Image: ${postFeatureImage}`);
+const newPost = await ghost.createPost({
+  title: 'My Awesome Post',
+  html: '<p>This is the content of my post.</p>',
+  feature_image: 'https://example.com/image.jpg',
+  tags: [{ id: 'tag-id' }],
+  excerpt: 'A brief summary of the post'
+});
 ```

-#### Updating a Post
-
-To update a post, you can use the `update` method. Make sure you have the necessary permissions and fields.
+Or create from HTML specifically:

 ```typescript
-const updatedPostData = {
+const post = await ghost.createPostFromHtml({
+  title: 'My HTML Post',
+  html: '<p>Content here</p>'
+});
+```
+
+### Update Post
+
+```typescript
+const post = await ghost.getPostById('post-id');
+await post.update({
  ...post.toJson(),
  title: 'Updated Title',
-  html: '<p>Updated HTML content</p>'
-};
-
-await post.update(updatedPostData);
-console.log('Post updated successfully');
+  html: '<p>Updated content</p>'
+});
 ```

-#### Deleting a Post
-
-To delete a post:
+### Delete Post

 ```typescript
+const post = await ghost.getPostById('post-id');
 await post.delete();
-console.log('Post deleted successfully');
 ```

-### Advanced Scenarios
+### Search Posts

-#### Creating a New Post
-
-You can create a new post using the `createPost` method of the `Ghost` class.
+Full-text search across post titles:

 ```typescript
-const newPostData = {
-  id: 'new-post-id',
-  title: 'New Post Title',
-  html: '<p>This is the content of the new post.</p>',
-  excerpt: 'New post excerpt',
-  feature_image: 'https://your-image-url.com/image.jpg'
-};
-
-const newPost = await ghostInstance.createPost(newPostData);
-
-console.log('New post created successfully');
-console.log(`ID: ${newPost.getId()}`);
-console.log(`Title: ${newPost.getTitle()}`);
+const results = await ghost.searchPosts('typescript tutorial', { limit: 10 });
+results.forEach(post => console.log(post.getTitle()));
 ```

-#### Error Handling
+### Related Posts

-Both the `Ghost` and `Post` classes throw errors that you can catch and handle.
+Get posts with similar tags:

 ```typescript
-try {
-  const posts = await ghostInstance.getPosts();
-  console.log('Posts fetched successfully');
-} catch (error) {
-  console.error('Error fetching posts:', error);
-}
+const post = await ghost.getPostById('post-id');
+const related = await ghost.getRelatedPosts(post.getId(), 5);
+related.forEach(p => console.log(`Related: ${p.getTitle()}`));
 ```

-Similarly, for updating or deleting a post:
+### Bulk Operations

 ```typescript
-try {
-  await post.update({ title: 'Updated Title' });
-  console.log('Post updated successfully');
-} catch (error) {
-  console.error('Error updating post:', error);
-}
-
-try {
-  await post.delete();
-  console.log('Post deleted successfully');
-} catch (error) {
-  console.error('Error deleting post:', error);
-}
-```
-
-#### Fetching Posts with Filters and Options
-
-The `getPosts` method can accept various filters and options.
-
-```typescript
-const filteredPosts = await ghostInstance.getPosts({ limit: 10, include: 'tags,authors' });
-
-filteredPosts.forEach(post => {
-  console.log(post.getTitle());
-});
-```
-
-#### Fetching Tags
-
-You can fetch all tags from your Ghost site using the `getTags` method.
-
-```typescript
-const tags = await ghostInstance.getTags();
-
-tags.forEach(tag => {
-  console.log(`${tag.name} (${tag.slug})`);
-});
-```
-
-#### Fetching Tags with Minimatch Filtering
-
-The `getTags` method supports filtering tags using minimatch patterns on tag slugs.
-
-```typescript
-// Fetch all tags starting with 'tech-'
-const techTags = await ghostInstance.getTags({ filter: 'tech-*' });
-
-// Fetch all tags containing 'blog'
-const blogTags = await ghostInstance.getTags({ filter: '*blog*' });
-
-// Fetch with limit
-const limitedTags = await ghostInstance.getTags({ limit: 10, filter: 'a*' });
-
-limitedTags.forEach(tag => {
-  console.log(tag.name);
-});
-```
-
-#### Working with Tag Class
-
-Fetch individual tags and manage them with the `Tag` class.
-
-```typescript
-// Get tag by slug
-const tag = await ghostInstance.getTagBySlug('tech');
-console.log(tag.getName());
-console.log(tag.getDescription());
-
-// Create a new tag
-const newTag = await ghostInstance.createTag({
-  name: 'JavaScript',
-  slug: 'javascript',
-  description: 'Posts about JavaScript'
+await ghost.bulkUpdatePosts(['id1', 'id2', 'id3'], {
+  featured: true
 });

-// Update a tag
-await newTag.update({
-  description: 'All things JavaScript'
-});
-
-// Delete a tag
-await newTag.delete();
+await ghost.bulkDeletePosts(['id4', 'id5', 'id6']);
 ```

-#### Fetching Authors
+## 📄 Pages

-Manage and filter authors with minimatch patterns.
+Pages work similarly to posts but are for static content:

 ```typescript
-// Get all authors
-const authors = await ghostInstance.getAuthors();
-authors.forEach(author => {
-  console.log(`${author.getName()} (${author.getSlug()})`);
-});
+const pages = await ghost.getPages();

-// Filter authors with minimatch
-const filteredAuthors = await ghostInstance.getAuthors({ filter: 'j*' });
+const aboutPage = await ghost.getPageBySlug('about');
+console.log(aboutPage.getHtml());

-// Get author by slug
-const author = await ghostInstance.getAuthorBySlug('john-doe');
-console.log(author.getBio());
-
-// Update author
-await author.update({
-  bio: 'Updated bio information'
-});
-```
-
-#### Working with Pages
-
-Ghost pages are similar to posts but for static content.
-
-```typescript
-// Get all pages
-const pages = await ghostInstance.getPages();
-pages.forEach(page => {
-  console.log(page.getTitle());
-});
-
-// Filter pages with minimatch
-const filteredPages = await ghostInstance.getPages({ filter: 'about*' });
-
-// Get page by slug
-const page = await ghostInstance.getPageBySlug('about');
-console.log(page.getHtml());
-
-// Create a new page
-const newPage = await ghostInstance.createPage({
-  title: 'Contact Us',
+const newPage = await ghost.createPage({
+  title: 'Contact',
  html: '<p>Contact information...</p>'
 });

-// Update a page
 await newPage.update({
-  html: '<p>Updated contact information...</p>'
+  html: '<p>Updated content</p>'
 });

-// Delete a page
 await newPage.delete();
 ```

-#### Enhanced Post Filtering
-
-The `getPosts` method now supports multiple filtering options.
+Filter pages with minimatch patterns:

 ```typescript
-// Filter by tag
-const techPosts = await ghostInstance.getPosts({ tag: 'tech', limit: 10 });
-
-// Filter by author
-const authorPosts = await ghostInstance.getPosts({ author: 'john-doe' });
-
-// Get only featured posts
-const featuredPosts = await ghostInstance.getPosts({ featured: true });
-
-// Combine multiple filters
-const filteredPosts = await ghostInstance.getPosts({
-  tag: 'javascript',
-  featured: true,
-  limit: 5
+const filteredPages = await ghost.getPages({ 
+  filter: 'about*',
+  limit: 10 
 });
 ```

-#### Searching Posts
+## 🏷️ Tags

-Full-text search across post titles and excerpts.
+### Get Tags

 ```typescript
-// Search for posts containing a keyword
-const searchResults = await ghostInstance.searchPosts('ghost api', { limit: 10 });
+const tags = await ghost.getTags();
+tags.forEach(tag => console.log(`${tag.name} (${tag.slug})`));
+```

-searchResults.forEach(post => {
-  console.log(post.getTitle());
-  console.log(post.getExcerpt());
+### Filter Tags with Minimatch
+
+```typescript
+const techTags = await ghost.getTags({ filter: 'tech-*' });
+const blogTags = await ghost.getTags({ filter: '*blog*' });
+```
+
+### Get Single Tag
+
+```typescript
+const tag = await ghost.getTagBySlug('javascript');
+console.log(tag.getName());
+console.log(tag.getDescription());
+```
+
+### Create, Update, Delete Tags
+
+```typescript
+const newTag = await ghost.createTag({
+  name: 'TypeScript',
+  slug: 'typescript',
+  description: 'All about TypeScript'
+});
+
+await newTag.update({
+  description: 'Everything TypeScript related'
+});
+
+await newTag.delete();
+```
+
+## 👤 Authors
+
+### Get Authors
+
+```typescript
+const authors = await ghost.getAuthors();
+authors.forEach(author => {
+  console.log(`${author.getName()} (${author.getSlug()})`);
 });
 ```

-#### Finding Related Posts
-
-Get posts with similar tags.
+### Filter Authors

 ```typescript
-const post = await ghostInstance.getPostById('some-post-id');
-
-// Get related posts based on tags
-const relatedPosts = await ghostInstance.getRelatedPosts(post.getId(), 5);
-
-relatedPosts.forEach(relatedPost => {
-  console.log(`Related: ${relatedPost.getTitle()}`);
+const filteredAuthors = await ghost.getAuthors({ 
+  filter: 'j*',
+  limit: 10 
 });
 ```

-#### Image Upload
-
-Upload images to your Ghost site.
+### Get Single Author

 ```typescript
-// Upload an image file
-const imageUrl = await ghostInstance.uploadImage('/path/to/image.jpg');
+const author = await ghost.getAuthorBySlug('john-doe');
+console.log(author.getBio());
+console.log(author.getProfileImage());
+```

-// Use the uploaded image URL in a post
-await ghostInstance.createPost({
+### Update Author
+
+```typescript
+await author.update({
+  bio: 'Updated bio information',
+  website: 'https://johndoe.com'
+});
+```
+
+## 👥 Members
+
+Manage your Ghost site members (requires Ghost membership features):
+
+### Get Members
+
+```typescript
+const members = await ghost.getMembers({ limit: 100 });
+members.forEach(member => {
+  console.log(`${member.getName()} - ${member.getEmail()}`);
+  console.log(`Status: ${member.getStatus()}`);
+});
+```
+
+### Filter Members
+
+```typescript
+const gmailMembers = await ghost.getMembers({ 
+  filter: '*@gmail.com' 
+});
+```
+
+### Get Single Member
+
+```typescript
+const member = await ghost.getMemberByEmail('user@example.com');
+console.log(member.getStatus());
+console.log(member.getLabels());
+```
+
+### Create Member
+
+```typescript
+const newMember = await ghost.createMember({
+  email: 'newuser@example.com',
+  name: 'New User',
+  note: 'VIP member'
+});
+```
+
+### Update and Delete Members
+
+```typescript
+await member.update({
+  name: 'Updated Name',
+  note: 'Premium member'
+});
+
+await member.delete();
+```
+
+## 🪝 Webhooks
+
+Manage webhooks for Ghost events:
+
+```typescript
+const webhook = await ghost.createWebhook({
+  event: 'post.published',
+  target_url: 'https://example.com/webhook',
+  name: 'Post Published Webhook'
+});
+
+await ghost.updateWebhook(webhook.id, {
+  target_url: 'https://example.com/new-webhook'
+});
+
+await ghost.deleteWebhook(webhook.id);
+```
+
+**Note:** The Ghost Admin API only supports creating, updating, and deleting webhooks. Browsing and reading individual webhooks are not supported by the underlying SDK.
+
+## 🖼️ Image Upload
+
+Upload images to your Ghost site:
+
+```typescript
+const imageUrl = await ghost.uploadImage('/path/to/image.jpg');
+
+await ghost.createPost({
  title: 'Post with Image',
  html: '<p>Content here</p>',
  feature_image: imageUrl
 });
 ```

-#### Bulk Operations
+## 🔄 Multi-Instance Synchronization

-Perform operations on multiple posts at once.
+The `SyncedInstance` class enables you to synchronize content across multiple Ghost instances - perfect for staging environments, multi-region deployments, or content distribution.
+
+### Setup

 ```typescript
-// Bulk update posts
-const postIds = ['id1', 'id2', 'id3'];
-await ghostInstance.bulkUpdatePosts(postIds, {
-  featured: true
+import { Ghost, SyncedInstance } from '@apiclient.xyz/ghost';
+
+const sourceGhost = new Ghost({
+  baseUrl: 'https://source.ghost.com',
+  contentApiKey: 'source_content_key',
+  adminApiKey: 'source_admin_key'
 });

-// Bulk delete posts
-await ghostInstance.bulkDeletePosts(['id4', 'id5']);
+const targetGhost1 = new Ghost({
+  baseUrl: 'https://target1.ghost.com',
+  contentApiKey: 'target1_content_key',
+  adminApiKey: 'target1_admin_key'
+});
+
+const targetGhost2 = new Ghost({
+  baseUrl: 'https://target2.ghost.com',
+  contentApiKey: 'target2_content_key',
+  adminApiKey: 'target2_admin_key'
+});
+
+const synced = new SyncedInstance(sourceGhost, [targetGhost1, targetGhost2]);
 ```

-### Example Projects
+### Sync Content

-To give you a comprehensive understanding, let's look at a couple of example projects.
+```typescript
+const tagReport = await synced.syncTags();
+console.log(`Synced ${tagReport.totalItems} tags`);
+console.log(`Duration: ${tagReport.duration}ms`);

-#### Example 1: A Basic Blog
+const postReport = await synced.syncPosts();
+console.log(`Success: ${postReport.targetReports[0].successCount}`);
+console.log(`Failed: ${postReport.targetReports[0].failureCount}`);

-In this scenario, we will create a simple script to fetch all posts and display their titles.
+const pageReport = await synced.syncPages();
+```
+
+### Sync Options
+
+```typescript
+const report = await synced.syncPosts({
+  filter: 'featured-*',
+  dryRun: true,
+  incremental: true
+});
+
+report.targetReports.forEach(targetReport => {
+  console.log(`Target: ${targetReport.targetUrl}`);
+  targetReport.results.forEach(result => {
+    console.log(`  ${result.sourceSlug}: ${result.status}`);
+  });
+});
+```
+
+### Sync Everything
+
+```typescript
+const reports = await synced.syncAll({
+  types: ['tags', 'posts', 'pages'],
+  syncOptions: {
+    dryRun: false
+  }
+});
+
+reports.forEach(report => {
+  console.log(`${report.contentType}: ${report.totalItems} items`);
+});
+```
+
+### Sync Status & History
+
+```typescript
+const status = synced.getSyncStatus();
+console.log(`Total mappings: ${status.totalMappings}`);
+console.log(`Recent syncs: ${status.recentSyncs.length}`);
+
+status.mappings.forEach(mapping => {
+  console.log(`Source: ${mapping.sourceSlug}`);
+  mapping.targetMappings.forEach(tm => {
+    console.log(`  -> ${tm.targetUrl} (${tm.targetId})`);
+  });
+});
+
+synced.clearSyncHistory();
+synced.clearMappings();
+```
+
+## 🎨 Complete Example
+
+Here's a comprehensive example showing various operations:

 ```typescript
 import { Ghost } from '@apiclient.xyz/ghost';

-(async () => {
-  const ghostInstance = new Ghost({
-    baseUrl: 'https://your-ghost-url.com',
-    contentApiKey: 'your-content-api-key',
-    adminApiKey: 'your-admin-api-key'
-  });
-
-  try {
-    const posts = await ghostInstance.getPosts();
-    posts.forEach(post => console.log(post.getTitle()));
-  } catch (error) {
-    console.error('Error fetching posts:', error);
-  }
-})();
-```
-
-#### Example 2: Post Management Tool
-
-In this example, let's create a tool that can fetch, create, update, and delete posts.
-
-```typescript
-import { Ghost, Post, IPostOptions } from '@apiclient.xyz/ghost';
-
-const ghostInstance = new Ghost({
-  baseUrl: 'https://your-ghost-url.com',
-  contentApiKey: 'your-content-api-key',
-  adminApiKey: 'your-admin-api-key'
+const ghost = new Ghost({
+  baseUrl: 'https://your-ghost-site.com',
+  contentApiKey: 'your_content_key',
+  adminApiKey: 'your_admin_key'
 });

-(async () => {
-  // Fetch posts
-  const posts = await ghostInstance.getPosts();
-  console.log('Fetched posts:');
-  posts.forEach(post => console.log(post.getTitle()));
+async function main() {
+  const imageUrl = await ghost.uploadImage('./banner.jpg');
+  
+  const tag = await ghost.createTag({
+    name: 'Tutorial',
+    slug: 'tutorial',
+    description: 'Step-by-step guides'
+  });

-  // Create a new post
-  const newPostData: IPostOptions = {
-    id: 'new-post-id',
-    title: 'New Post Title',
-    html: '<p>This is the content of the new post.</p>',
-  };
+  const post = await ghost.createPost({
+    title: 'Getting Started with Ghost',
+    html: '<h1>Welcome</h1><p>This is an introduction...</p>',
+    feature_image: imageUrl,
+    tags: [{ id: tag.getId() }],
+    featured: true
+  });

-  const newPost = await ghostInstance.createPost(newPostData);
-  console.log('New post created:', newPost.getTitle());
+  console.log(`Created post: ${post.getTitle()}`);
+  
+  const related = await ghost.getRelatedPosts(post.getId(), 5);
+  console.log(`Found ${related.length} related posts`);

-  // Update the new post
-  const updatedPost = await newPost.update({ title: 'Updated Post Title' });
-  console.log('Post updated:', updatedPost.getTitle());
+  const searchResults = await ghost.searchPosts('getting started', { limit: 10 });
+  console.log(`Search found ${searchResults.length} posts`);
+}

-  // Delete the new post
-  await updatedPost.delete();
-  console.log('Post deleted');
-})();
+main().catch(console.error);
 ```

-### Unit Tests
+## 🔒 Error Handling

-This package includes unit tests written using the `@push.rocks/tapbundle` and `@push.rocks/qenv` libraries. Here is how you can run them.
+All methods throw errors that you can catch and handle:

-1. Install the development dependencies:
+```typescript
+try {
+  const post = await ghost.getPostById('invalid-id');
+} catch (error) {
+  console.error('Failed to fetch post:', error);
+}
+
+try {
+  await post.update({ title: 'New Title' });
+} catch (error) {
+  console.error('Failed to update post:', error);
+}
+```
+
+## 📖 API Reference
+
+### Ghost Class
+
+| Method | Description | Returns |
+|--------|-------------|---------|
+| `getPosts(options?)` | Get all posts with optional filtering | `Promise<Post[]>` |
+| `getPostById(id)` | Get a single post by ID | `Promise<Post>` |
+| `createPost(data)` | Create a new post | `Promise<Post>` |
+| `createPostFromHtml(data)` | Create post from HTML | `Promise<Post>` |
+| `searchPosts(query, options?)` | Search posts by title | `Promise<Post[]>` |
+| `getRelatedPosts(postId, limit)` | Get related posts | `Promise<Post[]>` |
+| `bulkUpdatePosts(ids, updates)` | Update multiple posts | `Promise<Post[]>` |
+| `bulkDeletePosts(ids)` | Delete multiple posts | `Promise<void>` |
+| `getPages(options?)` | Get all pages | `Promise<Page[]>` |
+| `getPageById(id)` | Get page by ID | `Promise<Page>` |
+| `getPageBySlug(slug)` | Get page by slug | `Promise<Page>` |
+| `createPage(data)` | Create a new page | `Promise<Page>` |
+| `getTags(options?)` | Get all tags | `Promise<ITag[]>` |
+| `getTagById(id)` | Get tag by ID | `Promise<Tag>` |
+| `getTagBySlug(slug)` | Get tag by slug | `Promise<Tag>` |
+| `createTag(data)` | Create a new tag | `Promise<Tag>` |
+| `getAuthors(options?)` | Get all authors | `Promise<Author[]>` |
+| `getAuthorById(id)` | Get author by ID | `Promise<Author>` |
+| `getAuthorBySlug(slug)` | Get author by slug | `Promise<Author>` |
+| `getMembers(options?)` | Get all members | `Promise<Member[]>` |
+| `getMemberById(id)` | Get member by ID | `Promise<Member>` |
+| `getMemberByEmail(email)` | Get member by email | `Promise<Member>` |
+| `createMember(data)` | Create a new member | `Promise<Member>` |
+| `createWebhook(data)` | Create a webhook | `Promise<any>` |
+| `updateWebhook(id, data)` | Update a webhook | `Promise<any>` |
+| `deleteWebhook(id)` | Delete a webhook | `Promise<void>` |
+| `uploadImage(filePath)` | Upload an image | `Promise<string>` |
+
+### Post Class
+
+| Method | Description | Returns |
+|--------|-------------|---------|
+| `getId()` | Get post ID | `string` |
+| `getTitle()` | Get post title | `string` |
+| `getHtml()` | Get post HTML content | `string` |
+| `getExcerpt()` | Get post excerpt | `string` |
+| `getFeatureImage()` | Get feature image URL | `string \| undefined` |
+| `getAuthor()` | Get primary author | `IAuthor` |
+| `toJson()` | Get raw post data | `IPost` |
+| `update(data)` | Update the post | `Promise<Post>` |
+| `delete()` | Delete the post | `Promise<void>` |
+
+### Page Class
+
+| Method | Description | Returns |
+|--------|-------------|---------|
+| `getId()` | Get page ID | `string` |
+| `getTitle()` | Get page title | `string` |
+| `getHtml()` | Get page HTML content | `string` |
+| `getSlug()` | Get page slug | `string` |
+| `getFeatureImage()` | Get feature image URL | `string \| undefined` |
+| `getAuthor()` | Get primary author | `IAuthor` |
+| `toJson()` | Get raw page data | `IPage` |
+| `update(data)` | Update the page | `Promise<Page>` |
+| `delete()` | Delete the page | `Promise<void>` |
+
+### Tag Class
+
+| Method | Description | Returns |
+|--------|-------------|---------|
+| `getId()` | Get tag ID | `string` |
+| `getName()` | Get tag name | `string` |
+| `getSlug()` | Get tag slug | `string` |
+| `getDescription()` | Get tag description | `string \| undefined` |
+| `toJson()` | Get raw tag data | `ITag` |
+| `update(data)` | Update the tag | `Promise<Tag>` |
+| `delete()` | Delete the tag | `Promise<void>` |
+
+### Author Class
+
+| Method | Description | Returns |
+|--------|-------------|---------|
+| `getId()` | Get author ID | `string` |
+| `getName()` | Get author name | `string` |
+| `getSlug()` | Get author slug | `string` |
+| `getProfileImage()` | Get profile image URL | `string \| undefined` |
+| `getBio()` | Get author bio | `string \| undefined` |
+| `toJson()` | Get raw author data | `IAuthor` |
+| `update(data)` | Update the author | `Promise<Author>` |
+
+### Member Class
+
+| Method | Description | Returns |
+|--------|-------------|---------|
+| `getId()` | Get member ID | `string` |
+| `getEmail()` | Get member email | `string` |
+| `getName()` | Get member name | `string \| undefined` |
+| `getStatus()` | Get member status | `string \| undefined` |
+| `getLabels()` | Get member labels | `Array \| undefined` |
+| `toJson()` | Get raw member data | `IMember` |
+| `update(data)` | Update the member | `Promise<Member>` |
+| `delete()` | Delete the member | `Promise<void>` |
+
+### SyncedInstance Class
+
+| Method | Description | Returns |
+|--------|-------------|---------|
+| `syncPosts(options?)` | Sync posts to targets | `Promise<ISyncReport>` |
+| `syncPages(options?)` | Sync pages to targets | `Promise<ISyncReport>` |
+| `syncTags(options?)` | Sync tags to targets | `Promise<ISyncReport>` |
+| `syncAll(options?)` | Sync all content types | `Promise<ISyncReport[]>` |
+| `getSyncStatus()` | Get sync status & mappings | `Object` |
+| `clearSyncHistory()` | Clear sync history | `void` |
+| `clearMappings()` | Clear ID mappings | `void` |
+
+## 🧪 Testing

 ```bash
-npm install
+pnpm test
 ```

-2. Run the tests:
+## 📝 TypeScript Support

-```bash
-npm test
+This library is written in TypeScript and provides full type definitions out of the box. No `@types/*` package needed.
+
+```typescript
+import type { IPost, ITag, IAuthor, IMember } from '@apiclient.xyz/ghost';
 ```

-### Conclusion
+## 🤝 Contributing

-The `@apiclient.xyz/ghost` package provides a comprehensive and type-safe way to interact with the Ghost CMS API using TypeScript. The features provided by the `Ghost` and `Post` classes allow for a wide range of interactions, from basic CRUD operations to advanced filtering and error handling.
+This is an open-source project. Issues and pull requests are welcome!

-For more information, please refer to the [documentation](https://apiclient.xyz.gitlab.io/ghost/).
-undefined
+Repository: [https://code.foss.global/apiclient.xyz/ghost](https://code.foss.global/apiclient.xyz/ghost)
+
+## License and Legal Information
+
+This repository contains open-source code that is licensed under the MIT License. A copy of the MIT License can be found in the [license](license) file within this repository. **Please note:** The MIT License does not grant permission to use the trade names, trademarks, service marks, or product names of the project, except as required for reasonable and customary use in describing the origin of the work and reproducing the content of the NOTICE file.
+
+### Trademarks
+
+This project is owned and maintained by Task Venture Capital GmbH. The names and logos associated with Task Venture Capital GmbH and any related products or services are trademarks of Task Venture Capital GmbH and are not included within the scope of the MIT license granted herein. Use of these trademarks must comply with Task Venture Capital GmbH's Trademark Guidelines, and any usage must be approved in writing by Task Venture Capital GmbH.
+
+### Company Information
+
+Task Venture Capital GmbH  
+Registered at District court Bremen HRB 35230 HB, Germany
+
+For any legal inquiries or if you require further information, please contact us via email at hello@task.vc.
+
+By using this repository, you acknowledge that you have read this section, agree to comply with its terms, and understand that the licensing of the code does not imply endorsement by Task Venture Capital GmbH of any derivative works.
--- a/test/test.author.node.ts
+++ b/test/test.author.node.ts
@@ -0,0 +1,107 @@
+import { expect, tap } from '@push.rocks/tapbundle';
+import * as qenv from '@push.rocks/qenv';
+const testQenv = new qenv.Qenv('./', './.nogit/');
+
+import * as ghost from '../ts/index.js';
+
+let testGhostInstance: ghost.Ghost;
+
+tap.test('initialize Ghost instance', async () => {
+  testGhostInstance = new ghost.Ghost({
+    baseUrl: 'http://localhost:2368',
+    adminApiKey: await testQenv.getEnvVarOnDemand('ADMIN_APIKEY'),
+    contentApiKey: await testQenv.getEnvVarOnDemand('CONTENT_APIKEY'),
+  });
+  expect(testGhostInstance).toBeInstanceOf(ghost.Ghost);
+});
+
+tap.test('should get all authors', async () => {
+  const authors = await testGhostInstance.getAuthors();
+  expect(authors).toBeArray();
+  console.log(`Found ${authors.length} authors`);
+  if (authors.length > 0) {
+    expect(authors[0]).toBeInstanceOf(ghost.Author);
+    console.log(`First author: ${authors[0].getName()} (${authors[0].getSlug()})`);
+  }
+});
+
+tap.test('should get authors with limit', async () => {
+  const authors = await testGhostInstance.getAuthors({ limit: 2 });
+  expect(authors).toBeArray();
+  expect(authors.length).toBeLessThanOrEqual(2);
+});
+
+tap.test('should filter authors with minimatch pattern', async () => {
+  const authors = await testGhostInstance.getAuthors();
+  if (authors.length > 0) {
+    const firstAuthorSlug = authors[0].getSlug();
+    const pattern = `${firstAuthorSlug.charAt(0)}*`;
+    const filteredAuthors = await testGhostInstance.getAuthors({ filter: pattern });
+    expect(filteredAuthors).toBeArray();
+    console.log(`Filtered authors with pattern '${pattern}': found ${filteredAuthors.length}`);
+    filteredAuthors.forEach((author) => {
+      expect(author.getSlug()).toMatch(new RegExp(`^${firstAuthorSlug.charAt(0)}`));
+    });
+  }
+});
+
+tap.test('should get author by slug', async () => {
+  const authors = await testGhostInstance.getAuthors({ limit: 1 });
+  if (authors.length > 0) {
+    const author = await testGhostInstance.getAuthorBySlug(authors[0].getSlug());
+    expect(author).toBeInstanceOf(ghost.Author);
+    expect(author.getSlug()).toEqual(authors[0].getSlug());
+    console.log(`Got author by slug: ${author.getName()}`);
+  }
+});
+
+tap.test('should get author by ID', async () => {
+  const authors = await testGhostInstance.getAuthors({ limit: 1 });
+  if (authors.length > 0) {
+    const author = await testGhostInstance.getAuthorById(authors[0].getId());
+    expect(author).toBeInstanceOf(ghost.Author);
+    expect(author.getId()).toEqual(authors[0].getId());
+  }
+});
+
+tap.test('should access author methods', async () => {
+  const authors = await testGhostInstance.getAuthors({ limit: 1 });
+  if (authors.length > 0) {
+    const author = authors[0];
+    expect(author.getId()).toBeTruthy();
+    expect(author.getName()).toBeTruthy();
+    expect(author.getSlug()).toBeTruthy();
+    const json = author.toJson();
+    expect(json).toBeTruthy();
+    expect(json.id).toEqual(author.getId());
+  }
+});
+
+tap.test('should update author bio', async () => {
+  try {
+    const authors = await testGhostInstance.getAuthors({ limit: 1 });
+    if (authors.length > 0) {
+      const author = authors[0];
+      const originalBio = author.getBio();
+      
+      const updatedAuthor = await author.update({
+        bio: 'Updated bio for testing'
+      });
+      expect(updatedAuthor).toBeInstanceOf(ghost.Author);
+      expect(updatedAuthor.getBio()).toEqual('Updated bio for testing');
+      console.log(`Updated author bio: ${updatedAuthor.getName()}`);
+      
+      await updatedAuthor.update({
+        bio: originalBio
+      });
+    }
+  } catch (error: any) {
+    if (error.type === 'NotImplementedError') {
+      console.log('Author updates not supported in this Ghost version - skipping test');
+    } else {
+      throw error;
+    }
+  }
+});
+
+export default tap.start();
--- a/test/test.ghost.node.ts
+++ b/test/test.ghost.node.ts
@@ -0,0 +1,28 @@
+import { expect, tap } from '@push.rocks/tapbundle';
+import * as qenv from '@push.rocks/qenv';
+const testQenv = new qenv.Qenv('./', './.nogit/');
+
+import * as ghost from '../ts/index.js';
+
+let testGhostInstance: ghost.Ghost;
+
+tap.test('should create a valid instance of Ghost', async () => {
+  testGhostInstance = new ghost.Ghost({
+    baseUrl: 'http://localhost:2368',
+    adminApiKey: await testQenv.getEnvVarOnDemand('ADMIN_APIKEY'),
+    contentApiKey: await testQenv.getEnvVarOnDemand('CONTENT_APIKEY'),
+  });
+  expect(testGhostInstance).toBeInstanceOf(ghost.Ghost);
+  expect(testGhostInstance.options.baseUrl).toEqual('http://localhost:2368');
+});
+
+tap.test('should have adminApi configured', async () => {
+  expect(testGhostInstance.adminApi).toBeTruthy();
+});
+
+tap.test('should have contentApi configured', async () => {
+  expect(testGhostInstance.contentApi).toBeTruthy();
+});
+
+export default tap.start();
+export { testGhostInstance };
--- a/test/test.member.node.ts
+++ b/test/test.member.node.ts
@@ -0,0 +1,151 @@
+import { expect, tap } from '@push.rocks/tapbundle';
+import * as qenv from '@push.rocks/qenv';
+const testQenv = new qenv.Qenv('./', './.nogit/');
+
+import * as ghost from '../ts/index.js';
+
+let testGhostInstance: ghost.Ghost;
+let createdMember: ghost.Member;
+
+tap.test('initialize Ghost instance', async () => {
+  testGhostInstance = new ghost.Ghost({
+    baseUrl: 'http://localhost:2368',
+    adminApiKey: await testQenv.getEnvVarOnDemand('ADMIN_APIKEY'),
+    contentApiKey: await testQenv.getEnvVarOnDemand('CONTENT_APIKEY'),
+  });
+  expect(testGhostInstance).toBeInstanceOf(ghost.Ghost);
+});
+
+tap.test('should get all members', async () => {
+  try {
+    const members = await testGhostInstance.getMembers({ limit: 10 });
+    expect(members).toBeArray();
+    console.log(`Found ${members.length} members`);
+    if (members.length > 0) {
+      expect(members[0]).toBeInstanceOf(ghost.Member);
+      console.log(`First member: ${members[0].getEmail()}`);
+    }
+  } catch (error: any) {
+    if (error.message?.includes('members') || error.statusCode === 403) {
+      console.log('Members feature not available or requires permissions - skipping test');
+    } else {
+      throw error;
+    }
+  }
+});
+
+tap.test('should get members with limit', async () => {
+  try {
+    const members = await testGhostInstance.getMembers({ limit: 2 });
+    expect(members).toBeArray();
+    expect(members.length).toBeLessThanOrEqual(2);
+  } catch (error: any) {
+    if (error.message?.includes('members') || error.statusCode === 403) {
+      console.log('Members feature not available - skipping test');
+    } else {
+      throw error;
+    }
+  }
+});
+
+tap.test('should filter members with minimatch pattern', async () => {
+  try {
+    const members = await testGhostInstance.getMembers({ filter: '*@gmail.com' });
+    expect(members).toBeArray();
+    console.log(`Found ${members.length} Gmail members`);
+    if (members.length > 0) {
+      members.forEach((member) => {
+        expect(member.getEmail()).toContain('@gmail.com');
+      });
+    }
+  } catch (error: any) {
+    if (error.message?.includes('members') || error.statusCode === 403) {
+      console.log('Members feature not available - skipping test');
+    } else {
+      throw error;
+    }
+  }
+});
+
+tap.test('should create member', async () => {
+  try {
+    const timestamp = Date.now();
+    createdMember = await testGhostInstance.createMember({
+      email: `test${timestamp}@example.com`,
+      name: `Test Member ${timestamp}`
+    });
+    expect(createdMember).toBeInstanceOf(ghost.Member);
+    expect(createdMember.getEmail()).toEqual(`test${timestamp}@example.com`);
+    console.log(`Created member: ${createdMember.getId()}`);
+  } catch (error: any) {
+    if (error.message?.includes('members') || error.statusCode === 403) {
+      console.log('Members feature not available - skipping test');
+    } else {
+      throw error;
+    }
+  }
+});
+
+tap.test('should access member methods', async () => {
+  if (createdMember) {
+    expect(createdMember.getId()).toBeTruthy();
+    expect(createdMember.getEmail()).toBeTruthy();
+    expect(createdMember.getName()).toBeTruthy();
+    const json = createdMember.toJson();
+    expect(json).toBeTruthy();
+    expect(json.id).toEqual(createdMember.getId());
+  }
+});
+
+tap.test('should get member by email', async () => {
+  if (createdMember) {
+    try {
+      const member = await testGhostInstance.getMemberByEmail(createdMember.getEmail());
+      expect(member).toBeInstanceOf(ghost.Member);
+      expect(member.getEmail()).toEqual(createdMember.getEmail());
+    } catch (error: any) {
+      if (error.message?.includes('members') || error.statusCode === 403 || error.type === 'RequestNotAcceptableError') {
+        console.log('Member by email not supported in this Ghost version - using ID instead');
+        const member = await testGhostInstance.getMemberById(createdMember.getId());
+        expect(member).toBeInstanceOf(ghost.Member);
+      } else {
+        throw error;
+      }
+    }
+  }
+});
+
+tap.test('should update member', async () => {
+  if (createdMember) {
+    try {
+      const updatedMember = await createdMember.update({
+        note: 'Updated by automated tests'
+      });
+      expect(updatedMember).toBeInstanceOf(ghost.Member);
+      console.log(`Updated member: ${updatedMember.getId()}`);
+    } catch (error: any) {
+      if (error.message?.includes('members') || error.statusCode === 403) {
+        console.log('Members feature not available - skipping test');
+      } else {
+        throw error;
+      }
+    }
+  }
+});
+
+tap.test('should delete member', async () => {
+  if (createdMember) {
+    try {
+      await createdMember.delete();
+      console.log(`Deleted member: ${createdMember.getId()}`);
+    } catch (error: any) {
+      if (error.message?.includes('members') || error.statusCode === 403) {
+        console.log('Members feature not available - skipping test');
+      } else {
+        throw error;
+      }
+    }
+  }
+});
+
+export default tap.start();
--- a/test/test.page.node.ts
+++ b/test/test.page.node.ts
@@ -0,0 +1,106 @@
+import { expect, tap } from '@push.rocks/tapbundle';
+import * as qenv from '@push.rocks/qenv';
+const testQenv = new qenv.Qenv('./', './.nogit/');
+
+import * as ghost from '../ts/index.js';
+
+let testGhostInstance: ghost.Ghost;
+let createdPage: ghost.Page;
+
+tap.test('initialize Ghost instance', async () => {
+  testGhostInstance = new ghost.Ghost({
+    baseUrl: 'http://localhost:2368',
+    adminApiKey: await testQenv.getEnvVarOnDemand('ADMIN_APIKEY'),
+    contentApiKey: await testQenv.getEnvVarOnDemand('CONTENT_APIKEY'),
+  });
+  expect(testGhostInstance).toBeInstanceOf(ghost.Ghost);
+});
+
+tap.test('should get all pages', async () => {
+  const pages = await testGhostInstance.getPages();
+  expect(pages).toBeArray();
+  console.log(`Found ${pages.length} pages`);
+  if (pages.length > 0) {
+    expect(pages[0]).toBeInstanceOf(ghost.Page);
+    console.log(`First page: ${pages[0].getTitle()} (${pages[0].getSlug()})`);
+  }
+});
+
+tap.test('should get pages with limit', async () => {
+  const pages = await testGhostInstance.getPages({ limit: 3 });
+  expect(pages).toBeArray();
+  expect(pages.length).toBeLessThanOrEqual(3);
+});
+
+tap.test('should filter pages with minimatch pattern', async () => {
+  const pages = await testGhostInstance.getPages();
+  if (pages.length > 0) {
+    const firstPageSlug = pages[0].getSlug();
+    const pattern = `${firstPageSlug.charAt(0)}*`;
+    const filteredPages = await testGhostInstance.getPages({ filter: pattern });
+    expect(filteredPages).toBeArray();
+    console.log(`Filtered pages with pattern '${pattern}': found ${filteredPages.length}`);
+  }
+});
+
+tap.test('should get page by slug', async () => {
+  const pages = await testGhostInstance.getPages({ limit: 1 });
+  if (pages.length > 0) {
+    const page = await testGhostInstance.getPageBySlug(pages[0].getSlug());
+    expect(page).toBeInstanceOf(ghost.Page);
+    expect(page.getSlug()).toEqual(pages[0].getSlug());
+    console.log(`Got page by slug: ${page.getTitle()}`);
+  }
+});
+
+tap.test('should get page by ID', async () => {
+  const pages = await testGhostInstance.getPages({ limit: 1 });
+  if (pages.length > 0) {
+    const page = await testGhostInstance.getPageById(pages[0].getId());
+    expect(page).toBeInstanceOf(ghost.Page);
+    expect(page.getId()).toEqual(pages[0].getId());
+  }
+});
+
+tap.test('should create page', async () => {
+  const timestamp = Date.now();
+  createdPage = await testGhostInstance.createPage({
+    title: `Test Page ${timestamp}`,
+    html: '<p>This is a test page created by automated tests.</p>',
+    status: 'published'
+  } as any);
+  expect(createdPage).toBeInstanceOf(ghost.Page);
+  expect(createdPage.getTitle()).toEqual(`Test Page ${timestamp}`);
+  console.log(`Created page: ${createdPage.getId()}`);
+});
+
+tap.test('should access page methods', async () => {
+  if (createdPage) {
+    expect(createdPage.getId()).toBeTruthy();
+    expect(createdPage.getTitle()).toBeTruthy();
+    expect(createdPage.getSlug()).toBeTruthy();
+    const json = createdPage.toJson();
+    expect(json).toBeTruthy();
+    expect(json.id).toEqual(createdPage.getId());
+  }
+});
+
+tap.test('should update page', async () => {
+  if (createdPage) {
+    const updatedPage = await createdPage.update({
+      ...createdPage.pageData,
+      html: '<p>This page has been updated.</p>'
+    });
+    expect(updatedPage).toBeInstanceOf(ghost.Page);
+    console.log(`Updated page: ${updatedPage.getId()}`);
+  }
+});
+
+tap.test('should delete page', async () => {
+  if (createdPage) {
+    await createdPage.delete();
+    console.log(`Deleted page: ${createdPage.getId()}`);
+  }
+});
+
+export default tap.start();
--- a/test/test.post.node.ts
+++ b/test/test.post.node.ts
@@ -0,0 +1,144 @@
+import { expect, tap } from '@push.rocks/tapbundle';
+import * as qenv from '@push.rocks/qenv';
+const testQenv = new qenv.Qenv('./', './.nogit/');
+
+import * as ghost from '../ts/index.js';
+
+let testGhostInstance: ghost.Ghost;
+let createdPost: ghost.Post;
+
+tap.test('initialize Ghost instance', async () => {
+  testGhostInstance = new ghost.Ghost({
+    baseUrl: 'http://localhost:2368',
+    adminApiKey: await testQenv.getEnvVarOnDemand('ADMIN_APIKEY'),
+    contentApiKey: await testQenv.getEnvVarOnDemand('CONTENT_APIKEY'),
+  });
+  expect(testGhostInstance).toBeInstanceOf(ghost.Ghost);
+});
+
+tap.test('should get all posts', async () => {
+  const posts = await testGhostInstance.getPosts();
+  expect(posts).toBeArray();
+  if (posts.length > 0) {
+    expect(posts[0]).toBeInstanceOf(ghost.Post);
+    console.log(`Found ${posts.length} posts`);
+  }
+});
+
+tap.test('should get posts with limit', async () => {
+  const posts = await testGhostInstance.getPosts({ limit: 5 });
+  expect(posts).toBeArray();
+  expect(posts.length).toBeLessThanOrEqual(5);
+});
+
+tap.test('should filter posts by tag', async () => {
+  const tags = await testGhostInstance.getTags({ limit: 1 });
+  if (tags.length > 0) {
+    const posts = await testGhostInstance.getPosts({ tag: tags[0].slug, limit: 5 });
+    expect(posts).toBeArray();
+    console.log(`Found ${posts.length} posts with tag '${tags[0].name}'`);
+  }
+});
+
+tap.test('should filter posts by author', async () => {
+  const authors = await testGhostInstance.getAuthors({ limit: 1 });
+  if (authors.length > 0) {
+    const posts = await testGhostInstance.getPosts({ author: authors[0].getSlug(), limit: 5 });
+    expect(posts).toBeArray();
+    console.log(`Found ${posts.length} posts by author '${authors[0].getName()}'`);
+  }
+});
+
+tap.test('should filter posts by featured status', async () => {
+  const featuredPosts = await testGhostInstance.getPosts({ featured: true, limit: 5 });
+  expect(featuredPosts).toBeArray();
+  console.log(`Found ${featuredPosts.length} featured posts`);
+  if (featuredPosts.length > 0) {
+    expect(featuredPosts[0].postData.featured).toEqual(true);
+  }
+});
+
+tap.test('should search posts by title', async () => {
+  const searchResults = await testGhostInstance.searchPosts('the', { limit: 5 });
+  expect(searchResults).toBeArray();
+  console.log(`Found ${searchResults.length} posts matching 'the'`);
+});
+
+tap.test('should get post by ID', async () => {
+  const posts = await testGhostInstance.getPosts({ limit: 1 });
+  if (posts.length > 0) {
+    const post = await testGhostInstance.getPostById(posts[0].getId());
+    expect(post).toBeInstanceOf(ghost.Post);
+    expect(post.getId()).toEqual(posts[0].getId());
+  }
+});
+
+tap.test('should get related posts', async () => {
+  const posts = await testGhostInstance.getPosts({ limit: 1 });
+  if (posts.length > 0) {
+    const relatedPosts = await testGhostInstance.getRelatedPosts(posts[0].getId(), 3);
+    expect(relatedPosts).toBeArray();
+    console.log(`Found ${relatedPosts.length} related posts for '${posts[0].getTitle()}'`);
+  }
+});
+
+tap.test('should create post from HTML', async () => {
+  const timestamp = Date.now();
+  createdPost = await testGhostInstance.createPostFromHtml({
+    title: `Test Post ${timestamp}`,
+    html: '<p>This is a test post created by automated tests.</p>',
+    status: 'published'
+  } as any);
+  expect(createdPost).toBeInstanceOf(ghost.Post);
+  expect(createdPost.getTitle()).toEqual(`Test Post ${timestamp}`);
+  console.log(`Created post: ${createdPost.getId()}`);
+});
+
+tap.test('should access post methods', async () => {
+  if (createdPost) {
+    expect(createdPost.getId()).toBeTruthy();
+    expect(createdPost.getTitle()).toBeTruthy();
+    const json = createdPost.toJson();
+    expect(json).toBeTruthy();
+    expect(json.id).toEqual(createdPost.getId());
+  }
+});
+
+tap.test('should update post', async () => {
+  if (createdPost) {
+    const updatedPost = await createdPost.update({
+      ...createdPost.postData,
+      html: '<p>This post has been updated.</p>'
+    });
+    expect(updatedPost).toBeInstanceOf(ghost.Post);
+    console.log(`Updated post: ${updatedPost.getId()}`);
+  }
+});
+
+tap.test('should delete post', async () => {
+  if (createdPost) {
+    await createdPost.delete();
+    console.log(`Deleted post: ${createdPost.getId()}`);
+  }
+});
+
+tap.test('should bulk update posts', async () => {
+  const posts = await testGhostInstance.getPosts({ limit: 2 });
+  if (posts.length >= 2) {
+    const postIds = posts.map(p => p.getId());
+    const originalFeatured = posts[0].postData.featured;
+    
+    const updatedPosts = await testGhostInstance.bulkUpdatePosts(postIds, {
+      featured: !originalFeatured
+    });
+    expect(updatedPosts).toBeArray();
+    expect(updatedPosts.length).toEqual(postIds.length);
+    
+    await testGhostInstance.bulkUpdatePosts(postIds, {
+      featured: originalFeatured
+    });
+    console.log(`Bulk updated ${updatedPosts.length} posts`);
+  }
+});
+
+export default tap.start();
--- a/test/test.syncedinstance.node.ts
+++ b/test/test.syncedinstance.node.ts
@@ -0,0 +1,185 @@
+import { expect, tap } from '@push.rocks/tapbundle';
+import * as qenv from '@push.rocks/qenv';
+const testQenv = new qenv.Qenv('./', './.nogit/');
+
+import * as ghost from '../ts/index.js';
+
+let sourceGhost: ghost.Ghost;
+let targetGhost: ghost.Ghost;
+let syncedInstance: ghost.SyncedInstance;
+let testTag: ghost.Tag;
+let testPost: ghost.Post;
+let testPage: ghost.Page;
+
+tap.test('initialize source and target Ghost instances', async () => {
+  sourceGhost = new ghost.Ghost({
+    baseUrl: 'http://localhost:2368',
+    adminApiKey: await testQenv.getEnvVarOnDemand('ADMIN_APIKEY'),
+    contentApiKey: await testQenv.getEnvVarOnDemand('CONTENT_APIKEY'),
+  });
+  
+  targetGhost = new ghost.Ghost({
+    baseUrl: 'http://localhost:2368',
+    adminApiKey: await testQenv.getEnvVarOnDemand('ADMIN_APIKEY'),
+    contentApiKey: await testQenv.getEnvVarOnDemand('CONTENT_APIKEY'),
+  });
+  
+  expect(sourceGhost).toBeInstanceOf(ghost.Ghost);
+  expect(targetGhost).toBeInstanceOf(ghost.Ghost);
+});
+
+tap.test('create SyncedInstance', async () => {
+  syncedInstance = new ghost.SyncedInstance(sourceGhost, [targetGhost]);
+  expect(syncedInstance).toBeInstanceOf(ghost.SyncedInstance);
+  expect(syncedInstance.sourceGhost).toEqual(sourceGhost);
+  expect(syncedInstance.targetGhosts).toBeArray();
+  expect(syncedInstance.targetGhosts.length).toEqual(1);
+});
+
+tap.test('create test tag on source', async () => {
+  const timestamp = Date.now();
+  testTag = await sourceGhost.createTag({
+    name: `Sync Test Tag ${timestamp}`,
+    slug: `sync-test-tag-${timestamp}`,
+    description: 'This is a test tag for syncing'
+  });
+  expect(testTag).toBeInstanceOf(ghost.Tag);
+});
+
+tap.test('sync tags from source to target', async () => {
+  const report = await syncedInstance.syncTags();
+  
+  expect(report).toBeTruthy();
+  expect(report.contentType).toEqual('tags');
+  expect(report.totalItems).toBeGreaterThan(0);
+  expect(report.targetReports).toBeArray();
+  expect(report.targetReports.length).toEqual(1);
+  
+  const targetReport = report.targetReports[0];
+  expect(targetReport.results).toBeArray();
+});
+
+tap.test('verify sync status was tracked', async () => {
+  const status = syncedInstance.getSyncStatus();
+  expect(status.totalMappings).toBeGreaterThan(0);
+  expect(status.recentSyncs).toBeArray();
+  expect(status.recentSyncs.length).toBeGreaterThan(0);
+});
+
+tap.test('create test post on source', async () => {
+  const timestamp = Date.now();
+  testPost = await sourceGhost.createPost({
+    title: `Sync Test Post ${timestamp}`,
+    slug: `sync-test-post-${timestamp}`,
+    html: '<p>This is a test post for syncing</p>',
+    status: 'published',
+    tags: [{ id: testTag.tagData.id }]
+  });
+  expect(testPost).toBeInstanceOf(ghost.Post);
+});
+
+tap.test('sync posts from source to target', async () => {
+  const report = await syncedInstance.syncPosts();
+  
+  expect(report).toBeTruthy();
+  expect(report.contentType).toEqual('posts');
+  expect(report.totalItems).toBeGreaterThan(0);
+  expect(report.targetReports).toBeArray();
+  expect(report.targetReports.length).toEqual(1);
+});
+
+tap.test('verify post sync in status', async () => {
+  const status = syncedInstance.getSyncStatus();
+  expect(status.recentSyncs).toBeArray();
+  const postSync = status.recentSyncs.find(s => s.contentType === 'posts');
+  expect(postSync).toBeTruthy();
+});
+
+tap.test('create test page on source', async () => {
+  const timestamp = Date.now();
+  testPage = await sourceGhost.createPage({
+    title: `Sync Test Page ${timestamp}`,
+    slug: `sync-test-page-${timestamp}`,
+    html: '<p>This is a test page for syncing</p>',
+    status: 'published'
+  });
+  expect(testPage).toBeInstanceOf(ghost.Page);
+});
+
+tap.test('sync pages from source to target', async () => {
+  const report = await syncedInstance.syncPages();
+  
+  expect(report).toBeTruthy();
+  expect(report.contentType).toEqual('pages');
+  expect(report.totalItems).toBeGreaterThan(0);
+  expect(report.targetReports).toBeArray();
+  expect(report.targetReports.length).toEqual(1);
+});
+
+tap.test('verify page sync in status', async () => {
+  const status = syncedInstance.getSyncStatus();
+  const pageSync = status.recentSyncs.find(s => s.contentType === 'pages');
+  expect(pageSync).toBeTruthy();
+});
+
+tap.test('test syncAll method', async () => {
+  const reports = await syncedInstance.syncAll({ 
+    types: ['tags', 'posts', 'pages'],
+    syncOptions: { dryRun: true }
+  });
+  
+  expect(reports).toBeArray();
+  expect(reports.length).toEqual(3);
+  expect(reports[0].contentType).toEqual('tags');
+  expect(reports[1].contentType).toEqual('posts');
+  expect(reports[2].contentType).toEqual('pages');
+});
+
+tap.test('test clear methods', async () => {
+  syncedInstance.clearMappings();
+  syncedInstance.clearSyncHistory();
+  
+  const status = syncedInstance.getSyncStatus();
+  expect(status.totalMappings).toEqual(0);
+  expect(status.recentSyncs.length).toEqual(0);
+});
+
+tap.test('update tag and re-sync', async () => {
+  await testTag.update({
+    description: 'Updated description for sync test'
+  });
+  
+  const report = await syncedInstance.syncTags();
+  expect(report).toBeTruthy();
+  expect(report.totalItems).toBeGreaterThan(0);
+});
+
+tap.test('cleanup - delete synced content', async () => {
+  if (testPost) {
+    await testPost.delete();
+    const targetPosts = await targetGhost.getPosts({ filter: `slug:${testPost.postData.slug}` });
+    if (targetPosts.length > 0) {
+      await targetPosts[0].delete();
+    }
+  }
+  
+  if (testPage) {
+    await testPage.delete();
+    try {
+      const targetPage = await targetGhost.getPageBySlug(testPage.pageData.slug);
+      await targetPage.delete();
+    } catch (error) {
+    }
+  }
+  
+  if (testTag) {
+    await testTag.delete();
+    try {
+      const targetTag = await targetGhost.getTagBySlug(testTag.tagData.slug);
+      await targetTag.delete();
+    } catch (error) {
+    }
+  }
+});
+
+export default tap.start();
--- a/test/test.tag.node.ts
+++ b/test/test.tag.node.ts
@@ -0,0 +1,110 @@
+import { expect, tap } from '@push.rocks/tapbundle';
+import * as qenv from '@push.rocks/qenv';
+const testQenv = new qenv.Qenv('./', './.nogit/');
+
+import * as ghost from '../ts/index.js';
+
+let testGhostInstance: ghost.Ghost;
+let createdTag: ghost.Tag;
+
+tap.test('initialize Ghost instance', async () => {
+  testGhostInstance = new ghost.Ghost({
+    baseUrl: 'http://localhost:2368',
+    adminApiKey: await testQenv.getEnvVarOnDemand('ADMIN_APIKEY'),
+    contentApiKey: await testQenv.getEnvVarOnDemand('CONTENT_APIKEY'),
+  });
+  expect(testGhostInstance).toBeInstanceOf(ghost.Ghost);
+});
+
+tap.test('should get all tags', async () => {
+  const tags = await testGhostInstance.getTags();
+  expect(tags).toBeArray();
+  console.log(`Found ${tags.length} tags`);
+  if (tags.length > 0) {
+    console.log(`First tag: ${tags[0].name} (${tags[0].slug})`);
+  }
+});
+
+tap.test('should get tags with limit', async () => {
+  const tags = await testGhostInstance.getTags({ limit: 3 });
+  expect(tags).toBeArray();
+  expect(tags.length).toBeLessThanOrEqual(3);
+});
+
+tap.test('should filter tags with minimatch pattern', async () => {
+  const allTags = await testGhostInstance.getTags();
+  if (allTags.length > 0) {
+    const firstTagSlug = allTags[0].slug;
+    const pattern = `${firstTagSlug.charAt(0)}*`;
+    
+    const filteredTags = await testGhostInstance.getTags({ filter: pattern });
+    expect(filteredTags).toBeArray();
+    console.log(`Filtered tags with pattern '${pattern}': found ${filteredTags.length}`);
+    filteredTags.forEach((tag) => {
+      expect(tag.slug).toMatch(new RegExp(`^${firstTagSlug.charAt(0)}`));
+    });
+  }
+});
+
+tap.test('should get tag by slug', async () => {
+  const tags = await testGhostInstance.getTags({ limit: 1 });
+  if (tags.length > 0) {
+    const tag = await testGhostInstance.getTagBySlug(tags[0].slug);
+    expect(tag).toBeInstanceOf(ghost.Tag);
+    expect(tag.getSlug()).toEqual(tags[0].slug);
+    console.log(`Got tag by slug: ${tag.getName()}`);
+  }
+});
+
+tap.test('should get tag by ID', async () => {
+  const tags = await testGhostInstance.getTags({ limit: 1 });
+  if (tags.length > 0) {
+    const tag = await testGhostInstance.getTagById(tags[0].id);
+    expect(tag).toBeInstanceOf(ghost.Tag);
+    expect(tag.getId()).toEqual(tags[0].id);
+  }
+});
+
+tap.test('should create tag', async () => {
+  const timestamp = Date.now();
+  createdTag = await testGhostInstance.createTag({
+    name: `Test Tag ${timestamp}`,
+    slug: `test-tag-${timestamp}`,
+    description: 'A test tag created by automated tests'
+  });
+  expect(createdTag).toBeInstanceOf(ghost.Tag);
+  expect(createdTag.getName()).toEqual(`Test Tag ${timestamp}`);
+  console.log(`Created tag: ${createdTag.getId()}`);
+});
+
+tap.test('should access tag methods', async () => {
+  if (createdTag) {
+    expect(createdTag.getId()).toBeTruthy();
+    expect(createdTag.getName()).toBeTruthy();
+    expect(createdTag.getSlug()).toBeTruthy();
+    expect(createdTag.getDescription()).toBeTruthy();
+    const json = createdTag.toJson();
+    expect(json).toBeTruthy();
+    expect(json.id).toEqual(createdTag.getId());
+  }
+});
+
+tap.test('should update tag', async () => {
+  if (createdTag) {
+    const updatedTag = await createdTag.update({
+      description: 'Updated description for test tag'
+    });
+    expect(updatedTag).toBeInstanceOf(ghost.Tag);
+    expect(updatedTag.getDescription()).toEqual('Updated description for test tag');
+    console.log(`Updated tag: ${updatedTag.getId()}`);
+  }
+});
+
+tap.test('should delete tag', async () => {
+  if (createdTag) {
+    await createdTag.delete();
+    console.log(`Deleted tag: ${createdTag.getId()}`);
+  }
+});
+
+export default tap.start();
--- a/test/test.ts.old
+++ b/test/test.ts.old
@@ -138,4 +138,49 @@ tap.test('should get related posts', async () => {
  }
 });

+tap.test('should get members', async () => {
+  try {
+    const members = await testGhostInstance.getMembers({ limit: 10 });
+    expect(members).toBeArray();
+    console.log(`Found ${members.length} members`);
+    if (members.length > 0) {
+      console.log(`First member: ${members[0].getEmail()}`);
+    }
+  } catch (error: any) {
+    if (error.message?.includes('members') || error.statusCode === 403) {
+      console.log('Members feature not available or requires permissions');
+    } else {
+      throw error;
+    }
+  }
+});
+
+tap.test('should get settings', async () => {
+  try {
+    const settings = await testGhostInstance.getSettings();
+    expect(settings).toBeTruthy();
+    console.log(`Retrieved ${settings.settings?.length || 0} settings`);
+  } catch (error: any) {
+    if (error.message?.includes('undefined') || error.statusCode === 403) {
+      console.log('Settings API not available or requires different permissions');
+    } else {
+      throw error;
+    }
+  }
+});
+
+tap.test('should get webhooks', async () => {
+  try {
+    const webhooks = await testGhostInstance.getWebhooks();
+    expect(webhooks).toBeArray();
+    console.log(`Found ${webhooks.length} webhooks`);
+  } catch (error: any) {
+    if (error.message?.includes('not a function') || error.statusCode === 403) {
+      console.log('Webhooks API not available in this Ghost version');
+    } else {
+      throw error;
+    }
+  }
+});
+
 tap.start()
--- a/test/test.webhook.node.ts
+++ b/test/test.webhook.node.ts
@@ -0,0 +1,41 @@
+import { expect, tap } from '@push.rocks/tapbundle';
+import * as qenv from '@push.rocks/qenv';
+const testQenv = new qenv.Qenv('./', './.nogit/');
+
+import * as ghost from '../ts/index.js';
+
+let testGhostInstance: ghost.Ghost;
+let createdWebhook: any;
+
+tap.test('initialize Ghost instance', async () => {
+  testGhostInstance = new ghost.Ghost({
+    baseUrl: 'http://localhost:2368',
+    adminApiKey: await testQenv.getEnvVarOnDemand('ADMIN_APIKEY'),
+    contentApiKey: await testQenv.getEnvVarOnDemand('CONTENT_APIKEY'),
+  });
+  expect(testGhostInstance).toBeInstanceOf(ghost.Ghost);
+});
+
+tap.test('should create webhook', async () => {
+  const timestamp = Date.now();
+  createdWebhook = await testGhostInstance.createWebhook({
+    event: 'post.published',
+    target_url: `https://example.com/webhook/${timestamp}`,
+    name: `Test Webhook ${timestamp}`
+  });
+  expect(createdWebhook).toBeTruthy();
+  expect(createdWebhook.id).toBeTruthy();
+});
+
+tap.test('should update webhook', async () => {
+  const updatedWebhook = await testGhostInstance.updateWebhook(createdWebhook.id, {
+    target_url: 'https://example.com/webhook/updated'
+  });
+  expect(updatedWebhook).toBeTruthy();
+});
+
+tap.test('should delete webhook', async () => {
+  await testGhostInstance.deleteWebhook(createdWebhook.id);
+});
+
+export default tap.start();
--- a/ts/00_commitinfo_data.ts
+++ b/ts/00_commitinfo_data.ts
@@ -3,6 +3,6 @@
 */
 export const commitinfo = {
  name: '@apiclient.xyz/ghost',
-  version: '1.2.0',
+  version: '2.1.0',
  description: 'An unofficial Ghost CMS API package enabling content and admin functionality for managing posts.'
 }
--- a/ts/classes.author.ts
+++ b/ts/classes.author.ts
@@ -43,7 +43,6 @@ export class Author {
      this.authorData = updatedAuthorData;
      return this;
    } catch (error) {
-      console.error('Error updating author:', error);
      throw error;
    }
  }
--- a/ts/classes.ghost.ts
+++ b/ts/classes.ghost.ts
@@ -3,6 +3,7 @@ import { Post, type IPost, type ITag, type IAuthor } from './classes.post.js';
 import { Author } from './classes.author.js';
 import { Tag } from './classes.tag.js';
 import { Page, type IPage } from './classes.page.js';
+import { Member, type IMember } from './classes.member.js';

 export interface IGhostConstructorOptions {
  baseUrl: string;
@@ -64,7 +65,6 @@ export class Ghost {
      });
      return postsData.map((postData: IPost) => new Post(this, postData));
    } catch (error) {
-      console.error('Error fetching posts:', error);
      throw error;
    }
  }
@@ -72,9 +72,8 @@ export class Ghost {
  public async getPostById(id: string): Promise<Post> {
    try {
      const postData = await this.contentApi.posts.read({ id });
-      return new Post(postData, this.adminApi);
+      return new Post(this, postData);
    } catch (error) {
-      console.error(`Error fetching post with id ${id}:`, error);
      throw error;
    }
  }
@@ -82,9 +81,8 @@ export class Ghost {
  public async createPost(postData: IPost): Promise<Post> {
    try {
      const createdPostData = await this.adminApi.posts.add(postData);
-      return new Post(createdPostData, this.adminApi);
+      return new Post(this, createdPostData);
    } catch (error) {
-      console.error('Error creating post:', error);
      throw error;
    }
  }
@@ -109,7 +107,6 @@ export class Ghost {
      
      return tagsData;
    } catch (error) {
-      console.error('Error fetching tags:', error);
      throw error;
    }
  }
@@ -119,7 +116,6 @@ export class Ghost {
      const tagData = await this.contentApi.tags.read({ id });
      return new Tag(this, tagData);
    } catch (error) {
-      console.error(`Error fetching tag with id ${id}:`, error);
      throw error;
    }
  }
@@ -129,7 +125,6 @@ export class Ghost {
      const tagData = await this.contentApi.tags.read({ slug });
      return new Tag(this, tagData);
    } catch (error) {
-      console.error(`Error fetching tag with slug ${slug}:`, error);
      throw error;
    }
  }
@@ -139,7 +134,6 @@ export class Ghost {
      const createdTagData = await this.adminApi.tags.add(tagData);
      return new Tag(this, createdTagData);
    } catch (error) {
-      console.error('Error creating tag:', error);
      throw error;
    }
  }
@@ -158,7 +152,6 @@ export class Ghost {
      
      return authorsData.map((author: IAuthor) => new Author(this, author));
    } catch (error) {
-      console.error('Error fetching authors:', error);
      throw error;
    }
  }
@@ -168,7 +161,6 @@ export class Ghost {
      const authorData = await this.contentApi.authors.read({ id });
      return new Author(this, authorData);
    } catch (error) {
-      console.error(`Error fetching author with id ${id}:`, error);
      throw error;
    }
  }
@@ -178,7 +170,6 @@ export class Ghost {
      const authorData = await this.contentApi.authors.read({ slug });
      return new Author(this, authorData);
    } catch (error) {
-      console.error(`Error fetching author with slug ${slug}:`, error);
      throw error;
    }
  }
@@ -197,7 +188,6 @@ export class Ghost {
      
      return pagesData.map((pageData: IPage) => new Page(this, pageData));
    } catch (error) {
-      console.error('Error fetching pages:', error);
      throw error;
    }
  }
@@ -207,7 +197,6 @@ export class Ghost {
      const pageData = await this.contentApi.pages.read({ id });
      return new Page(this, pageData);
    } catch (error) {
-      console.error(`Error fetching page with id ${id}:`, error);
      throw error;
    }
  }
@@ -217,7 +206,6 @@ export class Ghost {
      const pageData = await this.contentApi.pages.read({ slug });
      return new Page(this, pageData);
    } catch (error) {
-      console.error(`Error fetching page with slug ${slug}:`, error);
      throw error;
    }
  }
@@ -227,7 +215,6 @@ export class Ghost {
      const createdPageData = await this.adminApi.pages.add(pageData);
      return new Page(this, createdPageData);
    } catch (error) {
-      console.error('Error creating page:', error);
      throw error;
    }
  }
@@ -242,7 +229,6 @@ export class Ghost {
      });
      return postsData.map((postData: IPost) => new Post(this, postData));
    } catch (error) {
-      console.error('Error searching posts:', error);
      throw error;
    }
  }
@@ -252,7 +238,6 @@ export class Ghost {
      const result = await this.adminApi.images.upload({ file: filePath });
      return result.url;
    } catch (error) {
-      console.error('Error uploading image:', error);
      throw error;
    }
  }
@@ -265,7 +250,6 @@ export class Ghost {
      });
      return await Promise.all(updatePromises);
    } catch (error) {
-      console.error('Error bulk updating posts:', error);
      throw error;
    }
  }
@@ -278,7 +262,6 @@ export class Ghost {
      });
      await Promise.all(deletePromises);
    } catch (error) {
-      console.error('Error bulk deleting posts:', error);
      throw error;
    }
  }
@@ -301,7 +284,82 @@ export class Ghost {
      
      return postsData.map((postData: IPost) => new Post(this, postData));
    } catch (error) {
-      console.error('Error fetching related posts:', error);
+      throw error;
+    }
+  }
+
+  public async getMembers(optionsArg?: { filter?: string; limit?: number }): Promise<Member[]> {
+    try {
+      const limit = optionsArg?.limit || 1000;
+      const membersData = await this.adminApi.members.browse({ limit });
+      
+      if (optionsArg?.filter) {
+        const matcher = new plugins.smartmatch.SmartMatch(optionsArg.filter);
+        return membersData
+          .filter((member: IMember) => matcher.match(member.email))
+          .map((member: IMember) => new Member(this, member));
+      }
+      
+      return membersData.map((member: IMember) => new Member(this, member));
+    } catch (error) {
+      throw error;
+    }
+  }
+
+  public async getMemberById(id: string): Promise<Member> {
+    try {
+      const memberData = await this.adminApi.members.read({ id });
+      return new Member(this, memberData);
+    } catch (error) {
+      throw error;
+    }
+  }
+
+  public async getMemberByEmail(email: string): Promise<Member> {
+    try {
+      const memberData = await this.adminApi.members.read({ email });
+      return new Member(this, memberData);
+    } catch (error) {
+      throw error;
+    }
+  }
+
+  public async createMember(memberData: Partial<IMember>): Promise<Member> {
+    try {
+      const createdMemberData = await this.adminApi.members.add(memberData);
+      return new Member(this, createdMemberData);
+    } catch (error) {
+      throw error;
+    }
+  }
+
+  public async createWebhook(webhookData: {
+    event: string;
+    target_url: string;
+    name?: string;
+    secret?: string;
+    api_version?: string;
+    integration_id?: string;
+  }): Promise<any> {
+    try {
+      return await this.adminApi.webhooks.add(webhookData);
+    } catch (error) {
+      throw error;
+    }
+  }
+
+  public async updateWebhook(id: string, webhookData: any): Promise<any> {
+    try {
+      return await this.adminApi.webhooks.edit({ ...webhookData, id });
+    } catch (error) {
+      throw error;
+    }
+  }
+
+  public async deleteWebhook(id: string): Promise<void> {
+    try {
+      await this.adminApi.webhooks.delete({ id });
+    } catch (error) {
      throw error;
    }
  }
--- a/ts/classes.member.ts
+++ b/ts/classes.member.ts
@@ -0,0 +1,85 @@
+import type { Ghost } from './classes.ghost.js';
+
+export interface IMember {
+  id: string;
+  uuid: string;
+  email: string;
+  name?: string;
+  note?: string;
+  geolocation?: string;
+  enable_comment_notifications?: boolean;
+  subscribed?: boolean;
+  email_count?: number;
+  email_opened_count?: number;
+  email_open_rate?: number;
+  status?: string;
+  created_at: string;
+  updated_at: string;
+  labels?: Array<{
+    id: string;
+    name: string;
+    slug: string;
+  }>;
+  subscriptions?: any[];
+  avatar_image?: string;
+  comped?: boolean;
+  email_suppression?: {
+    suppressed: boolean;
+    info?: string;
+  };
+}
+
+export class Member {
+  public ghostInstanceRef: Ghost;
+  public memberData: IMember;
+
+  constructor(ghostInstanceRefArg: Ghost, memberData: IMember) {
+    this.ghostInstanceRef = ghostInstanceRefArg;
+    this.memberData = memberData;
+  }
+
+  public getId(): string {
+    return this.memberData.id;
+  }
+
+  public getEmail(): string {
+    return this.memberData.email;
+  }
+
+  public getName(): string | undefined {
+    return this.memberData.name;
+  }
+
+  public getStatus(): string | undefined {
+    return this.memberData.status;
+  }
+
+  public getLabels(): Array<{ id: string; name: string; slug: string }> | undefined {
+    return this.memberData.labels;
+  }
+
+  public toJson(): IMember {
+    return this.memberData;
+  }
+
+  public async update(memberData: Partial<IMember>): Promise<Member> {
+    try {
+      const updatedMemberData = await this.ghostInstanceRef.adminApi.members.edit({
+        ...memberData,
+        id: this.getId()
+      });
+      this.memberData = updatedMemberData;
+      return this;
+    } catch (error) {
+      throw error;
+    }
+  }
+
+  public async delete(): Promise<void> {
+    try {
+      await this.ghostInstanceRef.adminApi.members.delete({ id: this.getId() });
+    } catch (error) {
+      throw error;
+    }
+  }
+}
--- a/ts/classes.page.ts
+++ b/ts/classes.page.ts
@@ -49,7 +49,6 @@ export class Page {
      this.pageData = updatedPageData;
      return this;
    } catch (error) {
-      console.error('Error updating page:', error);
      throw error;
    }
  }
@@ -58,7 +57,6 @@ export class Page {
    try {
      await this.ghostInstanceRef.adminApi.pages.delete({ id: this.getId() });
    } catch (error) {
-      console.error(`Error deleting page with id ${this.getId()}:`, error);
      throw error;
    }
  }
--- a/ts/classes.post.ts
+++ b/ts/classes.post.ts
@@ -124,7 +124,6 @@ export class Post {
      this.postData = updatedPostData;
      return this;
    } catch (error) {
-      console.error('Error updating post:', error);
      throw error;
    }
  }
@@ -133,7 +132,6 @@ export class Post {
    try {
      await this.ghostInstanceRef.adminApi.posts.delete({ id: this.getId() });
    } catch (error) {
-      console.error(`Error deleting post with id ${this.getId()}:`, error);
      throw error;
    }
  }
--- a/ts/classes.syncedinstance.ts
+++ b/ts/classes.syncedinstance.ts
@@ -0,0 +1,406 @@
+import * as plugins from './ghost.plugins.js';
+import { Ghost } from './classes.ghost.js';
+import { type IPost } from './classes.post.js';
+import { type IPage } from './classes.page.js';
+import { type ITag } from './classes.post.js';
+
+export interface ISyncOptions {
+  incremental?: boolean;
+  filter?: string;
+  dryRun?: boolean;
+}
+
+export interface ISyncItemResult {
+  sourceId: string;
+  sourceSlug: string;
+  targetId?: string;
+  status: 'created' | 'updated' | 'skipped' | 'failed';
+  error?: string;
+}
+
+export interface ISyncTargetReport {
+  targetUrl: string;
+  results: ISyncItemResult[];
+  successCount: number;
+  failureCount: number;
+}
+
+export interface ISyncReport {
+  contentType: 'posts' | 'pages' | 'tags';
+  totalItems: number;
+  targetReports: ISyncTargetReport[];
+  duration: number;
+  timestamp: Date;
+}
+
+export interface ISyncMapping {
+  sourceId: string;
+  sourceSlug: string;
+  targetMappings: Array<{
+    targetUrl: string;
+    targetId: string;
+    lastSynced: Date;
+  }>;
+}
+
+export class SyncedInstance {
+  public sourceGhost: Ghost;
+  public targetGhosts: Ghost[];
+  private syncMappings: Map<string, ISyncMapping>;
+  private syncHistory: ISyncReport[];
+
+  constructor(sourceGhost: Ghost, targetGhosts: Ghost[]) {
+    this.sourceGhost = sourceGhost;
+    this.targetGhosts = targetGhosts;
+    this.syncMappings = new Map();
+    this.syncHistory = [];
+  }
+
+  private addMapping(contentType: string, sourceId: string, sourceSlug: string, targetUrl: string, targetId: string) {
+    const key = `${contentType}:${sourceId}`;
+    const existing = this.syncMappings.get(key);
+    
+    if (existing) {
+      const targetMapping = existing.targetMappings.find(tm => tm.targetUrl === targetUrl);
+      if (targetMapping) {
+        targetMapping.targetId = targetId;
+        targetMapping.lastSynced = new Date();
+      } else {
+        existing.targetMappings.push({
+          targetUrl,
+          targetId,
+          lastSynced: new Date()
+        });
+      }
+    } else {
+      this.syncMappings.set(key, {
+        sourceId,
+        sourceSlug,
+        targetMappings: [{
+          targetUrl,
+          targetId,
+          lastSynced: new Date()
+        }]
+      });
+    }
+  }
+
+  private getMapping(contentType: string, sourceId: string, targetUrl: string): string | undefined {
+    const key = `${contentType}:${sourceId}`;
+    const mapping = this.syncMappings.get(key);
+    if (!mapping) return undefined;
+    
+    const targetMapping = mapping.targetMappings.find(tm => tm.targetUrl === targetUrl);
+    return targetMapping?.targetId;
+  }
+
+  public async syncTags(optionsArg?: ISyncOptions): Promise<ISyncReport> {
+    const startTime = Date.now();
+    const report: ISyncReport = {
+      contentType: 'tags',
+      totalItems: 0,
+      targetReports: [],
+      duration: 0,
+      timestamp: new Date()
+    };
+
+    const sourceTags = await this.sourceGhost.getTags(optionsArg?.filter ? { filter: optionsArg.filter } : {});
+    report.totalItems = sourceTags.length;
+
+    for (const targetGhost of this.targetGhosts) {
+      const targetReport: ISyncTargetReport = {
+        targetUrl: targetGhost.options.baseUrl,
+        results: [],
+        successCount: 0,
+        failureCount: 0
+      };
+
+      for (const sourceTag of sourceTags) {
+        try {
+          let targetTag: any;
+          let status: 'created' | 'updated' | 'skipped' = 'created';
+
+          try {
+            targetTag = await targetGhost.getTagBySlug(sourceTag.slug);
+            if (!optionsArg?.dryRun) {
+              await targetTag.update({
+                name: sourceTag.name,
+                description: sourceTag.description,
+                feature_image: sourceTag.feature_image,
+                visibility: sourceTag.visibility,
+                meta_title: sourceTag.meta_title,
+                meta_description: sourceTag.meta_description
+              });
+            }
+            status = 'updated';
+          } catch (error) {
+            if (!optionsArg?.dryRun) {
+              targetTag = await targetGhost.createTag({
+                name: sourceTag.name,
+                slug: sourceTag.slug,
+                description: sourceTag.description,
+                feature_image: sourceTag.feature_image,
+                visibility: sourceTag.visibility,
+                meta_title: sourceTag.meta_title,
+                meta_description: sourceTag.meta_description
+              });
+            }
+          }
+
+          if (!optionsArg?.dryRun && targetTag) {
+            this.addMapping('tags', sourceTag.id, sourceTag.slug, targetGhost.options.baseUrl, targetTag.tagData.id);
+          }
+
+          targetReport.results.push({
+            sourceId: sourceTag.id,
+            sourceSlug: sourceTag.slug,
+            targetId: targetTag?.tagData?.id,
+            status
+          });
+          targetReport.successCount++;
+        } catch (error) {
+          targetReport.results.push({
+            sourceId: sourceTag.id,
+            sourceSlug: sourceTag.slug,
+            status: 'failed',
+            error: error instanceof Error ? error.message : String(error)
+          });
+          targetReport.failureCount++;
+        }
+      }
+
+      report.targetReports.push(targetReport);
+    }
+
+    report.duration = Date.now() - startTime;
+    this.syncHistory.push(report);
+    return report;
+  }
+
+  public async syncPosts(optionsArg?: ISyncOptions): Promise<ISyncReport> {
+    const startTime = Date.now();
+    const report: ISyncReport = {
+      contentType: 'posts',
+      totalItems: 0,
+      targetReports: [],
+      duration: 0,
+      timestamp: new Date()
+    };
+
+    const sourcePosts = await this.sourceGhost.getPosts(optionsArg?.filter ? { filter: optionsArg.filter } : {});
+    report.totalItems = sourcePosts.length;
+
+    for (const targetGhost of this.targetGhosts) {
+      const targetReport: ISyncTargetReport = {
+        targetUrl: targetGhost.options.baseUrl,
+        results: [],
+        successCount: 0,
+        failureCount: 0
+      };
+
+      for (const sourcePost of sourcePosts) {
+        try {
+          const postData = sourcePost.postData;
+          
+          const tagSlugs = postData.tags?.map(t => t.slug) || [];
+          const targetTagIds: string[] = [];
+          
+          for (const tagSlug of tagSlugs) {
+            try {
+              const targetTag = await targetGhost.getTagBySlug(tagSlug);
+              targetTagIds.push(targetTag.tagData.id);
+            } catch (error) {
+            }
+          }
+
+          const syncData: any = {
+            title: postData.title,
+            slug: postData.slug,
+            html: postData.html,
+            feature_image: postData.feature_image,
+            featured: postData.featured,
+            status: postData.status,
+            visibility: postData.visibility,
+            meta_title: postData.meta_title,
+            meta_description: postData.meta_description,
+            published_at: postData.published_at,
+            custom_excerpt: postData.custom_excerpt,
+            tags: targetTagIds.length > 0 ? targetTagIds.map(id => ({ id })) : undefined
+          };
+
+          let targetPost: any;
+          let status: 'created' | 'updated' = 'created';
+
+          try {
+            targetPost = await targetGhost.contentApi.posts.read({ slug: postData.slug }, { formats: ['html'] });
+            if (!optionsArg?.dryRun) {
+              const updated = await targetGhost.adminApi.posts.edit({
+                ...syncData,
+                id: targetPost.id,
+                updated_at: targetPost.updated_at
+              });
+              targetPost = updated;
+            }
+            status = 'updated';
+          } catch (error) {
+            if (!optionsArg?.dryRun) {
+              targetPost = await targetGhost.adminApi.posts.add(syncData);
+            }
+          }
+
+          if (!optionsArg?.dryRun && targetPost) {
+            this.addMapping('posts', postData.id, postData.slug, targetGhost.options.baseUrl, targetPost.id);
+          }
+
+          targetReport.results.push({
+            sourceId: postData.id,
+            sourceSlug: postData.slug,
+            targetId: targetPost?.id,
+            status
+          });
+          targetReport.successCount++;
+        } catch (error) {
+          targetReport.results.push({
+            sourceId: sourcePost.postData.id,
+            sourceSlug: sourcePost.postData.slug,
+            status: 'failed',
+            error: error instanceof Error ? error.message : String(error)
+          });
+          targetReport.failureCount++;
+        }
+      }
+
+      report.targetReports.push(targetReport);
+    }
+
+    report.duration = Date.now() - startTime;
+    this.syncHistory.push(report);
+    return report;
+  }
+
+  public async syncPages(optionsArg?: ISyncOptions): Promise<ISyncReport> {
+    const startTime = Date.now();
+    const report: ISyncReport = {
+      contentType: 'pages',
+      totalItems: 0,
+      targetReports: [],
+      duration: 0,
+      timestamp: new Date()
+    };
+
+    const sourcePages = await this.sourceGhost.getPages(optionsArg?.filter ? { filter: optionsArg.filter } : {});
+    report.totalItems = sourcePages.length;
+
+    for (const targetGhost of this.targetGhosts) {
+      const targetReport: ISyncTargetReport = {
+        targetUrl: targetGhost.options.baseUrl,
+        results: [],
+        successCount: 0,
+        failureCount: 0
+      };
+
+      for (const sourcePage of sourcePages) {
+        try {
+          const pageData = sourcePage.pageData;
+
+          const syncData: Partial<IPage> = {
+            title: pageData.title,
+            slug: pageData.slug,
+            html: pageData.html,
+            feature_image: pageData.feature_image,
+            featured: pageData.featured,
+            status: pageData.status,
+            visibility: pageData.visibility,
+            meta_title: pageData.meta_title,
+            meta_description: pageData.meta_description,
+            published_at: pageData.published_at,
+            custom_excerpt: pageData.custom_excerpt
+          };
+
+          let targetPage: any;
+          let status: 'created' | 'updated' = 'created';
+
+          try {
+            targetPage = await targetGhost.contentApi.pages.read({ slug: pageData.slug }, { formats: ['html'] });
+            if (!optionsArg?.dryRun) {
+              const updated = await targetGhost.adminApi.pages.edit({
+                ...syncData,
+                id: targetPage.id,
+                updated_at: targetPage.updated_at
+              });
+              targetPage = updated;
+            }
+            status = 'updated';
+          } catch (error) {
+            if (!optionsArg?.dryRun) {
+              targetPage = await targetGhost.adminApi.pages.add(syncData);
+            }
+          }
+
+          if (!optionsArg?.dryRun && targetPage) {
+            this.addMapping('pages', pageData.id, pageData.slug, targetGhost.options.baseUrl, targetPage.id);
+          }
+
+          targetReport.results.push({
+            sourceId: pageData.id,
+            sourceSlug: pageData.slug,
+            targetId: targetPage?.id,
+            status
+          });
+          targetReport.successCount++;
+        } catch (error) {
+          targetReport.results.push({
+            sourceId: sourcePage.pageData.id,
+            sourceSlug: sourcePage.pageData.slug,
+            status: 'failed',
+            error: error instanceof Error ? error.message : String(error)
+          });
+          targetReport.failureCount++;
+        }
+      }
+
+      report.targetReports.push(targetReport);
+    }
+
+    report.duration = Date.now() - startTime;
+    this.syncHistory.push(report);
+    return report;
+  }
+
+  public async syncAll(optionsArg?: { types?: Array<'posts' | 'pages' | 'tags'>; syncOptions?: ISyncOptions }): Promise<ISyncReport[]> {
+    const types = optionsArg?.types || ['tags', 'posts', 'pages'];
+    const reports: ISyncReport[] = [];
+
+    for (const type of types) {
+      if (type === 'tags') {
+        reports.push(await this.syncTags(optionsArg?.syncOptions));
+      } else if (type === 'posts') {
+        reports.push(await this.syncPosts(optionsArg?.syncOptions));
+      } else if (type === 'pages') {
+        reports.push(await this.syncPages(optionsArg?.syncOptions));
+      }
+    }
+
+    return reports;
+  }
+
+  public getSyncStatus(): {
+    totalMappings: number;
+    mappings: ISyncMapping[];
+    recentSyncs: ISyncReport[];
+  } {
+    return {
+      totalMappings: this.syncMappings.size,
+      mappings: Array.from(this.syncMappings.values()),
+      recentSyncs: this.syncHistory.slice(-10)
+    };
+  }
+
+  public clearSyncHistory(): void {
+    this.syncHistory = [];
+  }
+
+  public clearMappings(): void {
+    this.syncMappings.clear();
+  }
+}
--- a/ts/classes.tag.ts
+++ b/ts/classes.tag.ts
@@ -39,7 +39,6 @@ export class Tag {
      this.tagData = updatedTagData;
      return this;
    } catch (error) {
-      console.error('Error updating tag:', error);
      throw error;
    }
  }
@@ -48,7 +47,6 @@ export class Tag {
    try {
      await this.ghostInstanceRef.adminApi.tags.delete({ id: this.getId() });
    } catch (error) {
-      console.error(`Error deleting tag with id ${this.getId()}:`, error);
      throw error;
    }
  }
--- a/ts/index.ts
+++ b/ts/index.ts
@@ -2,4 +2,6 @@ export * from './classes.ghost.js';
 export * from './classes.post.js';
 export * from './classes.author.js';
 export * from './classes.tag.js';
-export * from './classes.page.js';
+export * from './classes.page.js';
+export * from './classes.member.js';
+export * from './classes.syncedinstance.js';
Author	SHA1	Message	Date
Juergen Kunz	719bfafb93	2.1.0 Some checks failed Default (tags) / security (push) Failing after 21s Details Default (tags) / test (push) Failing after 12s Details Default (tags) / release (push) Has been skipped Details Default (tags) / metadata (push) Has been skipped Details	2025-10-08 09:57:59 +00:00
Juergen Kunz	d493d9fd01	feat(syncedinstance): Add SyncedInstance for multi-instance content synchronization, export it, add tests, and expand README	2025-10-08 09:57:59 +00:00
Juergen Kunz	63e514c1da	2.0.0 Some checks failed Default (tags) / security (push) Failing after 22s Details Default (tags) / test (push) Failing after 14s Details Default (tags) / release (push) Has been skipped Details Default (tags) / metadata (push) Has been skipped Details	2025-10-08 09:14:46 +00:00
Juergen Kunz	b3f08fb64c	BREAKING CHANGE(classes.ghost): Remove Settings and Webhooks browse/read APIs, remove noisy console.error logs, and update tests/docs	2025-10-08 09:14:45 +00:00
Juergen Kunz	7251e90395	1.4.1 Some checks failed Default (tags) / security (push) Failing after 12s Details Default (tags) / test (push) Failing after 13s Details Default (tags) / release (push) Has been skipped Details Default (tags) / metadata (push) Has been skipped Details	2025-10-07 14:31:54 +00:00
Juergen Kunz	62839e2f54	fix(tests): Remove updated_at from post and page update test payloads	2025-10-07 14:31:54 +00:00
Juergen Kunz	2d9844eb61	1.4.0 Some checks failed Default (tags) / security (push) Failing after 21s Details Default (tags) / test (push) Failing after 13s Details Default (tags) / release (push) Has been skipped Details Default (tags) / metadata (push) Has been skipped Details	2025-10-07 14:29:36 +00:00
Juergen Kunz	76c2b714b5	feat(classes.ghost): Add members, settings and webhooks support; implement Member class and add tests	2025-10-07 14:29:36 +00:00
Juergen Kunz	cf10f51089	1.3.0 Some checks failed Default (tags) / security (push) Failing after 13s Details Default (tags) / test (push) Failing after 12s Details Default (tags) / release (push) Has been skipped Details Default (tags) / metadata (push) Has been skipped Details	2025-10-07 13:55:01 +00:00
Juergen Kunz	2f05d0edc4	feat(core): Add Ghost CMS API client classes and README documentation	2025-10-07 13:55:00 +00:00