semanticpen/dist/core/SemanticPenClient.d.ts

AI Article Writer & SEO Blog Generator SDK - Professional TypeScript/JavaScript library for automated content creation, AI-powered article generation, and SEO blog writing with SemanticPen

import { PollingCallbacks } from '../utils/StatusPoller';
import { SemanticPenConfig, ArticleGenerationRequest, ArticleGenerationResponse, Article, PollingConfig, BulkOperationResult } from '../types';
export declare class SemanticPenClient {
    private readonly articleService;
    private readonly statusPoller;
    private readonly config;
    constructor(config: SemanticPenConfig);
    static create(apiKey: string, options?: Partial<SemanticPenConfig>): SemanticPenClient;
    static createWithConfig(config: SemanticPenConfig): SemanticPenClient;
    testConnection(): Promise<boolean>;
    getConfig(): Readonly<SemanticPenConfig>;
    generateArticle(keyword: string, options?: Partial<ArticleGenerationRequest>): Promise<{
        articleId: string;
        projectId: string;
        message: string;
    }>;
    generateArticles(keywords: string[], options?: Partial<ArticleGenerationRequest>): Promise<BulkOperationResult<{
        articleId: string;
        keyword: string;
    }>>;
    generateWithRequest(request: ArticleGenerationRequest): Promise<ArticleGenerationResponse>;
    getArticle(articleId: string): Promise<Article>;
    getArticles(articleIds: string[]): Promise<BulkOperationResult<Article>>;
    isArticleComplete(articleId: string): Promise<boolean>;
    getArticleStatus(articleId: string): Promise<{
        id: string;
        status: string;
        isComplete: boolean;
        hasError: boolean;
        errorMessage?: string;
    }>;
    waitForArticle(articleId: string, options?: {
        polling?: Partial<PollingConfig>;
        callbacks?: PollingCallbacks;
    }): Promise<Article>;
    waitForArticles(articleIds: string[], options?: {
        polling?: Partial<PollingConfig>;
        onProgress?: (completed: number, total: number, articles: Article[]) => void;
    }): Promise<{
        completed: Article[];
        failed: Array<{
            articleId: string;
            error: string;
        }>;
        totalTime: number;
    }>;
    getMultipleStatus(articleIds: string[]): Promise<{
        completed: Article[];
        pending: Article[];
        failed: Article[];
        notFound: string[];
    }>;
    generateAndWait(keyword: string, options?: {
        generation?: Partial<ArticleGenerationRequest>;
        polling?: Partial<PollingConfig>;
        callbacks?: PollingCallbacks;
    }): Promise<Article>;
    generateBulkAndWait(keywords: string[], options?: {
        generation?: Partial<ArticleGenerationRequest>;
        polling?: Partial<PollingConfig>;
        onProgress?: (completed: number, total: number, articles: Article[]) => void;
    }): Promise<{
        successful: Article[];
        failed: Array<{
            keyword: string;
            error: string;
        }>;
        totalTime: number;
    }>;
    static validateKeyword(keyword: string): boolean;
    static validateKeywords(keywords: string[]): {
        valid: boolean;
        errors: string[];
    };
    createRequestBuilder(): ArticleRequestBuilder;
}
export declare class ArticleRequestBuilder {
    private request;
    private client;
    constructor(client: SemanticPenClient);
    keyword(keyword: string | string[]): this;
    gptVersion(version: string): this;
    integration(id: string): this;
    preset(id: string): this;
    projectName(name: string): this;
    personalization(name: string): this;
    parameter(key: string, value: any): this;
    generate(): Promise<ArticleGenerationResponse>;
    generateAndWait(pollingConfig?: Partial<PollingConfig>, callbacks?: PollingCallbacks): Promise<Article | Article[]>;
    getRequest(): Readonly<Partial<ArticleGenerationRequest>>;
}
//# sourceMappingURL=SemanticPenClient.d.ts.map