@dalcontak/blogger-mcp-server 1.0.0

package/.github/workflows/publish.yml

@@ -0,0 +1,34 @@
+name: Build and Publish to npm
+
+on:
+  push:
+    branches:
+      - 'release/**'
+
+permissions:
+  id-token: write
+
+jobs:
+  build-and-publish:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v6
+        with:
+          node-version: '20'
+          registry-url: 'https://registry.npmjs.org'
+
+      - name: Install dependencies
+        run: npm ci
+
+      - name: Run tests
+        run: npm test
+
+      - name: Build
+        run: npm run build
+
+      - name: Publish to npm
+        run: npm publish --provenance --access public

package/AGENTS.md

@@ -0,0 +1,155 @@
+# AGENTS.md - Coding Agent Guidelines
+
+## Project Overview
+
+MCP (Model Context Protocol) server for Google's Blogger API. Allows AI models to
+interact with Blogger blogs via stdio or HTTP transport. Includes an optional web dashboard
+(Express + Socket.IO) on a separate port when `UI_PORT` is set. Written in TypeScript, targeting Node.js 20.
+
+Package: `@mcproadev/blogger-mcp-server` (v1.0.4)
+
+## Build / Run / Test Commands
+
+```bash
+# Install dependencies
+npm install
+
+# Build (compiles TypeScript to dist/)
+npm run build          # runs: tsc
+
+# Run production
+npm start              # runs: node dist/index.js
+
+# Run development
+npm run dev            # runs: ts-node src/index.ts
+
+# Lint
+npm run lint           # runs: eslint src/**/*.ts
+
+# Tests (jest is declared but NOT installed - no tests exist yet)
+npm test               # runs: jest
+# Single test (once jest + ts-jest are installed):
+#   npx jest path/to/file.test.ts
+#   npx jest -t "test name pattern"
+```
+
+**Note:** There is no eslint config file (`.eslintrc.*`). ESLint will use defaults.
+Jest is referenced in the test script but is not in devDependencies and no test files
+exist. If adding tests, install `jest`, `ts-jest`, and `@types/jest` first.
+
+## Project Structure
+
+```
+src/
+  index.ts            # Entry point, main() function, HTTP mode routing
+  server.ts           # MCP server tool registration (initMCPServer)
+  bloggerService.ts   # Google Blogger API wrapper (BloggerService class)
+  config.ts           # Environment-based configuration object
+  types.ts            # Shared interfaces and type definitions
+  ui-manager.ts       # Express + Socket.IO web dashboard
+public/               # Static web UI assets (HTML/JS/CSS)
+dist/                 # Compiled output (committed to repo)
+```
+
+## TypeScript Configuration
+
+- **Target:** ES2020, **Module:** CommonJS
+- **Strict mode:** enabled
+- **Declaration files:** generated in `dist/`
+- **Excludes:** `node_modules`, `dist`, `**/*.test.ts`
+
+## Environment Variables
+
+| Variable | Default | Description |
+|----------|---------|-------------|
+| `BLOGGER_API_KEY` | (optional) | Google Blogger API key (read-only access to public blogs) |
+| `GOOGLE_CLIENT_ID` | (optional) | OAuth2 client ID (for full read/write access) |
+| `GOOGLE_CLIENT_SECRET` | (optional) | OAuth2 client secret |
+| `GOOGLE_REFRESH_TOKEN` | (optional) | OAuth2 refresh token (scope: `blogger`) |
+| `MCP_MODE` | `stdio` | Transport: `stdio` or `http` |
+| `MCP_HTTP_HOST` | `0.0.0.0` | HTTP host |
+| `MCP_HTTP_PORT` | `3000` | HTTP port |
+| `BLOGGER_MAX_RESULTS` | `10` | Max results per query |
+| `BLOGGER_API_TIMEOUT` | `30000` | API timeout (ms) |
+| `LOG_LEVEL` | `info` | Logging level |
+| `UI_PORT` | (disabled) | Web dashboard port (set to enable) |
+
+**Authentication:** At least one auth method is required:
+- **API Key only** (`BLOGGER_API_KEY`): read-only access to public blogs. Works for `get_blog`,
+  `get_blog_by_url`, `list_posts`, `get_post`, `search_posts`, `list_labels`, `get_label`.
+- **OAuth2** (`GOOGLE_CLIENT_ID` + `GOOGLE_CLIENT_SECRET` + `GOOGLE_REFRESH_TOKEN`): full access.
+  Required for `list_blogs`, `create_post`, `update_post`, `delete_post`.
+- If both are set, OAuth2 is used (it covers all operations).
+
+## Code Style Guidelines
+
+### Imports
+
+- Use **named imports** for local modules: `import { config } from './config'`
+- Use **default imports** for third-party/Node.js modules: `import express from 'express'`
+- Use **relative paths** only (`./config`, `./types`) -- no path aliases
+- MCP SDK uses subpath imports with `.js` extension:
+  `import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js'`
+- Import order (not enforced but conventional):
+  1. Third-party packages
+  2. Node.js built-ins
+  3. Local modules
+
+### Naming Conventions
+
+| Element | Convention | Examples |
+|---------|-----------|----------|
+| Classes | PascalCase | `BloggerService`, `WebUIManager` |
+| Interfaces | PascalCase | `BloggerBlog`, `ServerConfig` |
+| Type aliases | PascalCase | `ServerMode` |
+| Functions | camelCase | `initMCPServer`, `listBlogs` |
+| Variables/properties | camelCase | `bloggerService`, `serverMode` |
+| MCP tool names | snake_case | `list_blogs`, `get_blog`, `get_blog_by_url`, `create_post` |
+| Environment vars | UPPER_SNAKE_CASE | `BLOGGER_API_KEY`, `MCP_MODE` |
+| Files | camelCase or kebab-case | `bloggerService.ts`, `ui-manager.ts` |
+
+### TypeScript Patterns
+
+- Prefer `interface` over `type` for object shapes; use `type` for unions/aliases
+- Use `Partial<T>` for optional update parameters
+- Use `zod` for runtime validation of MCP tool parameters
+- Use googleapis types directly: `blogger_v3.Schema$Blog`, `blogger_v3.Schema$Post`
+- Avoid `any` -- only acceptable in generic SDK mock/adapter code
+- Use `as const` for literal type narrowing where needed
+- All exports are **named exports** (no default exports)
+
+### Error Handling
+
+- Wrap async method bodies in `try/catch`
+- In service layer (`bloggerService.ts`): log with `console.error()`, then re-throw
+- In MCP tool handlers (`server.ts`): log with `console.error()`, return error response:
+  ```typescript
+  { content: [{ type: 'text', text: `Error message: ${error}` }], isError: true }
+  ```
+- In entry point (`index.ts`): catch fatal errors and call `process.exit(1)`
+- Error messages and console output are written in **French**
+- No custom error classes -- use plain `Error` or re-throw caught errors
+
+### Async Patterns
+
+- Use `async/await` exclusively -- no raw Promise chains
+- Use `Promise` constructor only when wrapping callback-based APIs (HTTP, streams)
+- Top-level `main()` is async and called directly
+
+### General Patterns
+
+- One module per file with single responsibility
+- Private/internal interfaces defined locally in the file that uses them
+- Class-based design for services (`BloggerService`, `WebUIManager`)
+- Functional approach for setup/registration (`initMCPServer`)
+
+## Known Issues / Gotchas
+
+- `dist/` directory is committed to the repo -- rebuild before committing if you change source
+- README.md has an unresolved merge conflict marker at line 171
+- HTTP mode in `index.ts` has a manual tool-routing switch that duplicates `server.ts` logic
+
+## Deployment
+
+- **Vercel:** configured via `vercel.json` (uses `@vercel/node`, HTTP mode, port 3000)
+- **Docker:** multi-stage build with `node:20-alpine`, runs as non-root, exposes port 3000

package/Dockerfile

@@ -0,0 +1,64 @@
+# Dockerfile amélioré pour blogger-mcp-server (compatibilité Glama)
+
+# Étape 1: Construction de l'application
+FROM node:20-alpine AS builder
+
+# Définir le répertoire de travail
+WORKDIR /app
+
+# Copier les fichiers de manifeste et de verrouillage des dépendances
+COPY package.json package-lock.json* ./
+
+# Installer les dépendances de production et de développement pour la compilation
+RUN npm install
+
+# Copier le reste des fichiers sources de l'application
+COPY . .
+
+# Compiler le projet TypeScript
+RUN npm run build
+
+# Supprimer les dépendances de développement après la compilation
+RUN npm prune --production
+
+# Étape 2: Création de l'image de production
+FROM node:20-alpine
+
+# Définir le répertoire de travail
+WORKDIR /app
+
+# Créer un utilisateur non-root pour exécuter l'application
+RUN addgroup -S appgroup && adduser -S appuser -G appgroup
+
+# Copier les dépendances de production et les fichiers compilés depuis l'étape de construction
+COPY --from=builder /app/node_modules ./node_modules
+COPY --from=builder /app/dist ./dist
+COPY --from=builder /app/package.json ./
+
+# Définir les variables d'environnement
+# BLOGGER_API_KEY doit être fournie à l'exécution (docker run -e BLOGGER_API_KEY=VOTRE_CLE)
+ENV MCP_MODE=http
+ENV MCP_HTTP_HOST=0.0.0.0
+ENV MCP_HTTP_PORT=3000
+ENV BLOGGER_MAX_RESULTS=10
+ENV BLOGGER_API_TIMEOUT=30000
+ENV LOG_LEVEL=info
+# NODE_ENV=production est souvent une bonne pratique pour les applications Node.js
+ENV NODE_ENV=production
+
+# Exposer le port sur lequel l'application écoute
+EXPOSE 3000
+
+# Changer le propriétaire des fichiers de l'application pour l'utilisateur non-root
+RUN chown -R appuser:appgroup /app
+
+# Basculer vers l'utilisateur non-root
+USER appuser
+
+# Commande pour démarrer le serveur
+CMD ["node", "dist/index.js"]
+
+# Métadonnées de l'image (optionnel, mais recommandé)
+LABEL maintainer="niyonabil"
+LABEL description="Serveur MCP pour interagir avec l'API Blogger de Google."
+LABEL version="1.0.4" # Se baser sur la version du package.json si possible

package/README.md

@@ -0,0 +1,169 @@
+# blogger-mcp-server
+=======
+# Serveur MCP pour Blogger
+
+Un serveur MCP (Model Context Protocol) qui permet aux modèles d'intelligence artificielle comme Claude d'interagir directement avec l'API Blogger de Google.
+
+## À propos
+
+Ce projet implémente un serveur compatible avec le protocole MCP (Model Context Protocol) pour l'API Blogger de Google. Il permet aux modèles d'IA comme Claude d'interagir avec les blogs Blogger pour :
+
+* Lister et récupérer des blogs
+* Lister, rechercher, récupérer, créer, mettre à jour et supprimer des posts
+* Lister et récupérer des labels
+
+> **Note importante** : L'API Blogger de Google ne permet pas de créer de nouveaux blogs via API. Cette limitation est documentée par Google. Les blogs doivent être créés manuellement via l'interface web de Blogger.
+
+## Prérequis
+
+* Node.js (version 16 ou supérieure)
+* Une clé API Blogger de Google
+
+## Installation
+
+### Installation depuis npm
+
+```bash
+npm install -g @mcproadev/blogger-mcp-server
+```
+
+### Installation depuis le code source
+
+```bash
+git clone https://github.com/niyonabil/blogger-mcp-server.git
+cd blogger-mcp-server
+npm install
+npm run build
+```
+if error install : 
+
+```bash
+npm install --save-dev @types/express
+```
+## Configuration
+
+### Obtenir une clé API Blogger
+
+1. Accédez à la [Console Google Cloud](https://console.cloud.google.com/)
+2. Créez un nouveau projet ou sélectionnez un projet existant
+3. Activez l'API Blogger v3
+4. Créez une clé API
+5. Notez cette clé pour l'utiliser dans la configuration
+
+### Configuration du serveur MCP
+
+Créez un fichier de configuration pour votre client MCP. Voici un exemple pour Claude Desktop :
+
+```json
+{
+  "mcpServers": {
+    "blogger": {
+      "command": "npx",
+      "args": [
+        "-y",
+        "@mcproadev/blogger-mcp-server"
+      ],
+      "env": {
+        "BLOGGER_API_KEY": "VOTRE_CLE_API_ICI"
+      }
+    }
+  }
+}
+```
+
+Remplacez `VOTRE_CLE_API_ICI` par la clé API que vous avez obtenue.
+
+## Utilisation
+
+### Démarrage local
+
+Le projet inclut deux scripts pour faciliter le démarrage du serveur :
+
+#### Mode développement
+
+```bash
+export BLOGGER_API_KEY=votre_cle_api
+./start-dev.sh
+```
+
+Ce script vérifie la présence de la clé API, installe les dépendances si nécessaire, compile le projet si nécessaire, puis démarre le serveur en mode développement.
+
+#### Mode production
+
+```bash
+export BLOGGER_API_KEY=votre_cle_api
+npm run build
+./start-prod.sh
+```
+
+Ce script vérifie la présence de la clé API et que le projet est compilé, puis démarre le serveur en mode production.
+
+### Utilisation avec un client MCP
+
+Une fois configuré, vous pouvez utiliser le serveur MCP pour Blogger avec n'importe quel client MCP compatible, comme Claude Desktop.
+
+Exemples de commandes :
+
+* "Liste tous mes blogs Blogger"
+* "Crée un nouveau post sur mon blog avec l'ID 123456 avec le titre 'Mon nouveau post' et le contenu 'Voici le contenu de mon post'"
+* "Recherche des posts contenant le mot 'technologie' dans mon blog"
+* "Mets à jour le post avec l'ID 789012 pour changer son titre en 'Nouveau titre'"
+
+## Options de déploiement
+
+### Déploiement sur Vercel
+
+Le projet inclut un fichier `vercel.json` pour faciliter le déploiement sur Vercel :
+
+1. Créez un compte sur [Vercel](https://vercel.com/) si vous n'en avez pas déjà un
+2. Installez l'outil CLI Vercel : `npm install -g vercel`
+3. Connectez-vous à votre compte Vercel : `vercel login`
+4. Configurez votre variable d'environnement secrète : `vercel secrets add blogger_api_key "VOTRE_CLE_API_ICI"`
+5. Déployez le projet : `vercel`
+
+### Déploiement avec Docker
+
+Le projet inclut un Dockerfile pour faciliter le déploiement dans un conteneur Docker :
+
+1. Construisez l'image Docker :
+   ```bash
+   docker build -t blogger-mcp-server .
+   ```
+
+2. Exécutez le conteneur :
+   ```bash
+   docker run -p 3000:3000 -e BLOGGER_API_KEY=votre_cle_api blogger-mcp-server
+   ```
+
+### Autres options de déploiement
+
+Le serveur peut également être déployé sur d'autres plateformes compatibles avec Node.js :
+
+1. **Heroku** : Utilisez un Procfile et les variables d'environnement Heroku
+2. **AWS Lambda** : Utilisez un adaptateur comme Serverless Framework
+3. **Google Cloud Run** : Utilisez le Dockerfile inclus
+
+## Structure du projet
+
+Le serveur MCP pour Blogger est composé de plusieurs modules :
+
+* `index.ts` : Point d'entrée principal
+* `server.ts` : Configuration du serveur MCP
+* `bloggerService.ts` : Service d'interaction avec l'API Blogger
+* `config.ts` : Configuration du serveur
+* `types.ts` : Définition des types et interfaces
+
+## Limitations connues
+
+* **Création de blogs** : L'API Blogger de Google ne permet pas de créer de nouveaux blogs via API. Les blogs doivent être créés manuellement via l'interface web de Blogger.
+* **Recherche de posts** : La recherche utilise l'endpoint natif `posts/search?q=` de l'API Blogger v3.
+* **Gestion des labels** : L'API Blogger ne fournit pas d'endpoints directs pour la gestion des labels. Cette fonctionnalité est implémentée en extrayant les labels des posts.
+* **Authentification** : Le serveur supporte l'authentification par clé API (lecture seule, blogs publics) et OAuth2 (accès complet en lecture/écriture). OAuth2 est requis pour `list_blogs`, `create_post`, `update_post`, `delete_post`.
+
+## Contribution
+
+Les contributions sont les bienvenues ! N'hésitez pas à ouvrir une issue ou une pull request.
+
+## Licence
+
+Ce projet est sous licence MIT.

package/RELEASE.md

@@ -0,0 +1,125 @@
+# Release Process for @dalcontak/blogger-mcp-server
+
+This document explains how to create releases and publish to npm.
+
+## Prerequisites
+
+### Setup Trusted Publishing (OIDC)
+
+IMPORTANT: npm classic tokens are deprecated (revoked Nov 19, 2025). Fine-grained tokens have a 90-day maximum lifetime. The recommended approach is **Trusted Publishing (OIDC)**.
+
+#### Step 1: Configure GitHub Actions as Trusted Publisher
+
+The correct navigation is:
+1. Go to https://www.npmjs.com/package/@dalcontak/blogger-mcp-server
+2. Click on **"Settings"** tab
+3. Find the **"Trusted Publishers"** section
+4. Click on **"GitHub Actions"** (or "Set up connection" button)
+5. Fill in:
+   - **Organization or user**: `dalcontak`
+   - **Repository**: `dalcontak/blogger-mcp-server`
+   - **Workflow filename**: `publish.yml` (name of the workflow file, NOT the full path)
+6. Click **"Set up connection"**
+
+Optional but recommended:
+- ✅ **Require two-factor authentication**
+- ✅ **Disallow tokens** (forces OIDC usage)
+
+That's it! No token needed — OIDC generates short-lived, job-specific credentials automatically.
+
+## Version Naming
+
+Follow semantic versioning: `MAJOR.MINOR.PATCH`
+
+Examples:
+- `1.0.0` - Initial release
+- `1.0.1` - Bug fix
+- `1.1.0` - New feature
+- `2.0.0` - Breaking change
+
+## Release Process
+
+### Step 1: Update version in package.json
+
+```bash
+# Open package.json and update version
+# "version": "1.1.7"
+```
+
+### Step 2: Commit version bump
+
+```bash
+git add package.json
+git commit -m "chore: bump version to 1.1.7"
+```
+
+### Step 3: Create and push release branch
+
+Branch naming convention: `release-X.Y.Z`
+
+```bash
+# Create release branch with version in name
+git checkout -b release-1.1.7
+
+# Merge main into release branch
+git merge main
+
+# Push to GitHub
+git push -u origin release-1.1.7
+```
+
+### Step 4: Automated Build and Publish
+
+GitHub Actions will automatically:
+1. ✅ Checkout code
+2. ✅ Setup Node.js v20
+3. ✅ Install dependencies
+4. ✅ Run tests (npm test)
+5. ✅ Build (npm run build)
+6. ✅ Publish to npm using OIDC (no manual token needed)
+
+The workflow triggers on any push to branches matching `release/**`.
+
+## Install Published Version
+
+After successful publish:
+
+```bash
+# Global install
+npm install -g @dalcontak/blogger-mcp-server
+
+# Local install in a project
+npm install @dalcontak/blogger-mcp-server
+```
+
+## Notes
+
+- The branch name **must** contain version after "release-" (e.g., `release-1.1.7`)
+- Version format: **3 digits separated by dots** (X.Y.Z)
+- Only pushes to `release/**` branches trigger the build/publish workflow
+- **No GitHub secrets needed** for OIDC — just configure trusted publisher connection
+- Requires Node.js >= 11.5.1 (npm automatically detects OIDC credentials)
+
+## Troubleshooting
+
+### Error: "You are not set up to publish with OIDC"
+
+Make sure:
+1. GitHub Actions is configured as **Trusted Publisher** in npm settings
+2. Workflow filename matches: `publish.yml`
+3. Repository is correct: `dalcontak/blogger-mcp-server`
+4. Workflow has `permissions: id-token: write`
+
+### Error: "npm publish --provenance requires Node.js >= 11.5.1"
+
+The workflow uses `actions/setup-node@v6` which sets up Node.js 20. If you see this error, check your Node.js version.
+
+## Comparison: Tokens vs OIDC
+
+| Aspect | Classic Tokens | Fine-grained Tokens | Trusted Publishing (OIDC) |
+|---------|----------------|--------------------|---------------------------|
+| **Status** | ❌ Deprecated (revoked) | ⚠️ Limited to 90 days | ✅ Recommended |
+| **Rotation** | Manual (every 90 days max) | Manual (every 90 days max) | Automatic (job-specific) |
+| **Security** | Long-lived, stored in secrets | Short-lived, stored in secrets | Short-lived, job-specific |
+| **GitHub Secret** | Required (NPM_TOKEN) | Required (NPM_TOKEN) | ❌ Not needed |
+| **Setup** | Create token, add to secrets | Create token, add to secrets | Configure in npmjs.com |

package/dist/bloggerService.d.ts

@@ -0,0 +1,121 @@
+import { blogger_v3 } from 'googleapis';
+import { BloggerBlog, BloggerPost, BloggerLabel } from './types';
+/**
+ * Custom types to compensate for Blogger API limitations
+ */
+interface BloggerLabelList {
+    kind?: string;
+    items?: BloggerLabel[];
+}
+/**
+ * Google Blogger API interaction service
+ *
+ * Supports two authentication modes:
+ * - OAuth2 (GOOGLE_CLIENT_ID + GOOGLE_CLIENT_SECRET + GOOGLE_REFRESH_TOKEN):
+ *   full access (read + write). Required for listBlogs, createPost, updatePost, deletePost.
+ * - API Key (BLOGGER_API_KEY): read-only access to public blogs.
+ *   Works for getBlog, listPosts, getPost, searchPosts, listLabels, getLabel.
+ *
+ * If both are configured, OAuth2 is used (it covers all operations).
+ */
+export declare class BloggerService {
+    private blogger;
+    private readonly isOAuth2;
+    /**
+     * Initializes the Blogger service with OAuth2 or API key
+     */
+    constructor();
+    /**
+     * Checks that OAuth2 authentication is available.
+     * Throws an explicit error if the operation requires OAuth2 and we are in API key mode.
+     */
+    private requireOAuth2;
+    /**
+     * Lists all blogs for the authenticated user.
+     * Requires OAuth2 (blogs.listByUser with userId: 'self').
+     * @returns Blog list
+     */
+    listBlogs(): Promise<blogger_v3.Schema$BlogList>;
+    /**
+     * Retrieves details of a specific blog
+     * @param blogId ID of the blog to retrieve
+     * @returns Blog details
+     */
+    getBlog(blogId: string): Promise<blogger_v3.Schema$Blog>;
+    /**
+     * Retrieves a blog by its URL
+     * @param url Blog URL
+     * @returns Blog details
+     */
+    getBlogByUrl(url: string): Promise<blogger_v3.Schema$Blog>;
+    /**
+     * Simulates blog creation.
+     * Note: The Blogger API does not actually allow creating a blog via API.
+     * This method simulates the functionality and returns an explanatory error message.
+     *
+     * @param blogData Blog data to create
+     * @returns Explanatory error message
+     */
+    createBlog(blogData: Partial<BloggerBlog>): Promise<any>;
+    /**
+     * Lists posts from a blog
+     * @param blogId Blog ID
+     * @param maxResults Maximum number of results to return
+     * @returns Post list
+     */
+    listPosts(blogId: string, maxResults?: number): Promise<blogger_v3.Schema$PostList>;
+    /**
+     * Searches posts in a blog using the native posts.search endpoint of the Blogger API
+     * @param blogId Blog ID
+     * @param query Search term
+     * @param maxResults Maximum number of results to return
+     * @returns List of matching posts
+     */
+    searchPosts(blogId: string, query: string, maxResults?: number): Promise<blogger_v3.Schema$PostList>;
+    /**
+     * Retrieves a specific post
+     * @param blogId Blog ID
+     * @param postId Post ID
+     * @returns Post details
+     */
+    getPost(blogId: string, postId: string): Promise<blogger_v3.Schema$Post>;
+    /**
+     * Creates a new post in a blog.
+     * Requires OAuth2.
+     * @param blogId Blog ID
+     * @param postData Post data to create
+     * @returns Created post
+     */
+    createPost(blogId: string, postData: Partial<BloggerPost>): Promise<blogger_v3.Schema$Post>;
+    /**
+     * Updates an existing post.
+     * Requires OAuth2.
+     * @param blogId Blog ID
+     * @param postId Post ID
+     * @param postData Post data to update
+     * @returns Updated post
+     */
+    updatePost(blogId: string, postId: string, postData: Partial<BloggerPost>): Promise<blogger_v3.Schema$Post>;
+    /**
+     * Deletes a post.
+     * Requires OAuth2.
+     * @param blogId Blog ID
+     * @param postId Post ID
+     * @returns Deletion status
+     */
+    deletePost(blogId: string, postId: string): Promise<void>;
+    /**
+     * Lists labels from a blog
+     * @param blogId Blog ID
+     * @returns Label list
+     */
+    listLabels(blogId: string): Promise<BloggerLabelList>;
+    /**
+     * Retrieves a specific label
+     * @param blogId Blog ID
+     * @param labelName Label name
+     * @returns Label details
+     */
+    getLabel(blogId: string, labelName: string): Promise<BloggerLabel>;
+}
+export {};