weavebot-core/dist/index.d.ts

Generic content processing framework for web scraping and AI extraction

import { z } from 'zod';
import { P as Pipeline, b as ProcessingStep, c as ProcessingContext, d as PipelineBuilder, e as ProcessorConfig, f as ProcessorPlugin, S as StorageAdapter, C as CommandHandler, g as CommandContext, h as CommandResult, i as ProcessorInput, j as ProcessorResult } from './index-1GgaWFHn.js';
export { A as AIExtractionParams, E as ExtractionError, a as LogContext, L as Logger, N as NewsletterOptions, t as PipelineError, k as ScrapedContent, r as ScrapingError, o as ScrapingOptions, n as ScrapingStrategy, s as StorageError, m as StorageFilter, p as StorageParams, l as StorageRecord, V as ValidationError, q as WeaveBotError, W as WebScrapingParams } from './index-1GgaWFHn.js';
export { SchemaRegistry, createSchemaRegistry, defaultSchemaRegistry } from './schemas.js';
export { AIExtractionConfig, AIExtractionProcessor, GenericExtractionConfig, WebScraperConfig, WebScraperProcessor, createAIExtractor, createWebScraper } from './processors.js';
export { AirtableConfig, AirtableStorageAdapter, createAirtableAdapter } from './storage.js';
export { LogLevel, createLogger, defaultLogger, formatDuration, isValidUrl, retry, sanitizeInput, sleep, truncateText } from './utils.js';
import 'playwright';

declare class ContentPipeline implements Pipeline {
    readonly name: string;
    readonly steps: ProcessingStep[];
    constructor(name: string, steps: ProcessingStep[]);
    execute(input: unknown, context?: ProcessingContext): Promise<unknown>;
}
declare class ContentPipelineBuilder implements PipelineBuilder {
    private name;
    private steps;
    constructor(name: string);
    addStep(step: ProcessingStep): PipelineBuilder;
    build(): Pipeline;
}
declare class FunctionStep implements ProcessingStep {
    readonly name: string;
    private fn;
    constructor(name: string, fn: (input: unknown, context: ProcessingContext) => Promise<unknown>);
    execute(input: unknown, context: ProcessingContext): Promise<unknown>;
}
declare class ValidationStep implements ProcessingStep {
    readonly name = "validation";
    private validator;
    private errorMessage;
    constructor(validator: (data: unknown) => boolean, errorMessage?: string);
    execute(input: unknown, context: ProcessingContext): Promise<unknown>;
}
declare class TransformStep implements ProcessingStep {
    readonly name: string;
    private transformer;
    constructor(name: string, transformer: (data: unknown, context: ProcessingContext) => unknown);
    execute(input: unknown, context: ProcessingContext): Promise<unknown>;
}
declare class PipelineRegistry {
    private pipelines;
    register(pipeline: Pipeline): void;
    get(name: string): Pipeline | undefined;
    execute(name: string, input: unknown, context?: ProcessingContext): Promise<unknown>;
    list(): string[];
}
declare const createPipeline: (name: string) => ContentPipelineBuilder;
declare const createFunctionStep: (name: string, fn: (input: unknown, context: ProcessingContext) => Promise<unknown>) => FunctionStep;
declare const createValidationStep: (validator: (data: unknown) => boolean, errorMessage?: string) => ValidationStep;
declare const createTransformStep: (name: string, transformer: (data: unknown, context: ProcessingContext) => unknown) => TransformStep;
declare const defaultPipelineRegistry: PipelineRegistry;

declare class ContentProcessor {
    private config;
    private processors;
    private storageAdapters;
    private commandHandlers;
    private schemaRegistry;
    private pipelineRegistry;
    private logger;
    constructor(config?: ProcessorConfig);
    addProcessor(name: string, processor: ProcessorPlugin): void;
    getProcessor(name: string): ProcessorPlugin | undefined;
    addStorage(name: string, adapter: StorageAdapter): void;
    getStorage(name: string): StorageAdapter | undefined;
    addCommandHandler(command: string, handler: CommandHandler): void;
    executeCommand(command: string, context: CommandContext): Promise<CommandResult>;
    registerSchema<T>(name: string, schema: z.ZodType<T>, fieldMapping?: Record<string, string>): void;
    getSchema(name: string): z.ZodType | undefined;
    registerPipeline(pipeline: Pipeline): void;
    executePipeline(name: string, input: unknown, context?: ProcessingContext): Promise<unknown>;
    process(input: ProcessorInput, context?: ProcessingContext): Promise<ProcessorResult>;
    private processUrl;
    private processText;
    private processFile;
    listProcessors(): string[];
    listStorageAdapters(): string[];
    listCommands(): string[];
    listSchemas(): string[];
    listPipelines(): string[];
}

export { CommandContext, CommandHandler, CommandResult, ContentPipeline, ContentPipelineBuilder, ContentProcessor, FunctionStep, Pipeline, PipelineBuilder, PipelineRegistry, ProcessingContext, ProcessingStep, ProcessorConfig, ProcessorInput, ProcessorPlugin, ProcessorResult, StorageAdapter, TransformStep, ValidationStep, createFunctionStep, createPipeline, createTransformStep, createValidationStep, ContentProcessor as default, defaultPipelineRegistry };