@stack0/sdk 0.2.8 → 0.2.9

package/dist/extraction/index.d.mts

@@ -0,0 +1,374 @@
+import { H as HttpClientConfig } from '../http-client-Wr9lXo9_.mjs';
+import { E as Environment, B as BatchJobStatus, S as ScheduleFrequency, C as CreateBatchResponse, G as GetBatchJobRequest, L as ListBatchJobsRequest, c as CreateScheduleResponse, a as GetScheduleRequest, b as ListSchedulesRequest } from '../shared-types-B0PyC7cF.mjs';
+
+/**
+ * Type definitions for Stack0 AI Extraction API
+ */
+
+type ExtractionStatus = "pending" | "processing" | "completed" | "failed";
+type ExtractionMode = "auto" | "schema" | "markdown" | "raw";
+interface PageMetadata {
+    title?: string;
+    description?: string;
+    ogImage?: string;
+    favicon?: string;
+    links?: string[];
+    images?: string[];
+}
+interface ExtractionResult {
+    id: string;
+    organizationId: string;
+    projectId: string | null;
+    environment: Environment;
+    url: string;
+    mode: string;
+    status: ExtractionStatus;
+    extractedData: Record<string, unknown> | null;
+    markdown: string | null;
+    rawHtml: string | null;
+    pageMetadata: PageMetadata | null;
+    error: string | null;
+    processingTimeMs: number | null;
+    tokensUsed: number | null;
+    metadata: Record<string, unknown> | null;
+    createdAt: Date;
+    completedAt: Date | null;
+}
+interface CreateExtractionRequest {
+    url: string;
+    environment?: Environment;
+    projectId?: string;
+    mode?: ExtractionMode;
+    schema?: Record<string, unknown>;
+    prompt?: string;
+    includeLinks?: boolean;
+    includeImages?: boolean;
+    includeMetadata?: boolean;
+    waitForSelector?: string;
+    waitForTimeout?: number;
+    headers?: Record<string, string>;
+    cookies?: Array<{
+        name: string;
+        value: string;
+        domain?: string;
+    }>;
+    webhookUrl?: string;
+    webhookSecret?: string;
+    metadata?: Record<string, unknown>;
+}
+interface CreateExtractionResponse {
+    id: string;
+    status: ExtractionStatus;
+}
+interface GetExtractionRequest {
+    id: string;
+    environment?: Environment;
+    projectId?: string;
+}
+interface ListExtractionsRequest {
+    environment?: Environment;
+    projectId?: string;
+    status?: ExtractionStatus;
+    url?: string;
+    limit?: number;
+    cursor?: string;
+}
+interface ListExtractionsResponse {
+    items: ExtractionResult[];
+    nextCursor?: string;
+}
+interface BatchExtractionJob {
+    id: string;
+    organizationId: string;
+    projectId: string | null;
+    environment: Environment;
+    type: "extraction";
+    name: string | null;
+    status: BatchJobStatus;
+    urls: string[];
+    config: Record<string, unknown>;
+    totalUrls: number;
+    processedUrls: number;
+    successfulUrls: number;
+    failedUrls: number;
+    webhookUrl: string | null;
+    metadata: Record<string, unknown> | null;
+    createdAt: Date;
+    startedAt: Date | null;
+    completedAt: Date | null;
+}
+interface CreateBatchExtractionsRequest {
+    urls: string[];
+    environment?: Environment;
+    projectId?: string;
+    name?: string;
+    config?: {
+        mode?: ExtractionMode;
+        schema?: Record<string, unknown>;
+        prompt?: string;
+        includeLinks?: boolean;
+        includeImages?: boolean;
+        includeMetadata?: boolean;
+        waitForSelector?: string;
+        waitForTimeout?: number;
+    };
+    webhookUrl?: string;
+    webhookSecret?: string;
+    metadata?: Record<string, unknown>;
+}
+interface ExtractionBatchJobsResponse {
+    items: BatchExtractionJob[];
+    nextCursor?: string;
+}
+interface ExtractionSchedule {
+    id: string;
+    organizationId: string;
+    projectId: string | null;
+    environment: Environment;
+    name: string;
+    url: string;
+    type: "extraction";
+    frequency: ScheduleFrequency;
+    config: Record<string, unknown>;
+    isActive: boolean;
+    detectChanges: boolean;
+    changeThreshold: number | null;
+    webhookUrl: string | null;
+    totalRuns: number;
+    successfulRuns: number;
+    failedRuns: number;
+    lastRunAt: Date | null;
+    nextRunAt: Date | null;
+    metadata: Record<string, unknown> | null;
+    createdAt: Date;
+    updatedAt: Date;
+}
+interface CreateExtractionScheduleRequest {
+    name: string;
+    url: string;
+    environment?: Environment;
+    projectId?: string;
+    frequency?: ScheduleFrequency;
+    config: {
+        mode?: ExtractionMode;
+        schema?: Record<string, unknown>;
+        prompt?: string;
+        includeLinks?: boolean;
+        includeImages?: boolean;
+        includeMetadata?: boolean;
+        waitForSelector?: string;
+        waitForTimeout?: number;
+    };
+    detectChanges?: boolean;
+    changeThreshold?: number;
+    webhookUrl?: string;
+    webhookSecret?: string;
+    metadata?: Record<string, unknown>;
+}
+interface UpdateExtractionScheduleRequest {
+    id: string;
+    environment?: Environment;
+    projectId?: string;
+    name?: string;
+    frequency?: ScheduleFrequency;
+    config?: Record<string, unknown>;
+    isActive?: boolean;
+    detectChanges?: boolean;
+    changeThreshold?: number;
+    webhookUrl?: string | null;
+    webhookSecret?: string | null;
+    metadata?: Record<string, unknown>;
+}
+interface ExtractionSchedulesResponse {
+    items: ExtractionSchedule[];
+    nextCursor?: string;
+}
+interface ExtractionUsage {
+    periodStart: Date;
+    periodEnd: Date;
+    extractionsTotal: number;
+    extractionsSuccessful: number;
+    extractionsFailed: number;
+    extractionCreditsUsed: number;
+    extractionTokensUsed: number;
+}
+interface GetUsageRequest {
+    environment?: Environment;
+    periodStart?: string;
+    periodEnd?: string;
+}
+
+/**
+ * Stack0 AI Extraction Client
+ * Extract structured data from any webpage using AI
+ */
+
+declare class Extraction {
+    private http;
+    constructor(config: HttpClientConfig);
+    /**
+     * Extract content from a URL
+     *
+     * @example
+     * ```typescript
+     * const { id, status } = await extraction.extract({
+     *   url: 'https://example.com/article',
+     *   mode: 'markdown',
+     *   includeMetadata: true,
+     * });
+     *
+     * // Poll for completion
+     * const result = await extraction.get({ id });
+     * console.log(result.markdown);
+     * ```
+     */
+    extract(request: CreateExtractionRequest): Promise<CreateExtractionResponse>;
+    /**
+     * Get an extraction by ID
+     *
+     * @example
+     * ```typescript
+     * const extraction = await extraction.get({ id: 'extraction-id' });
+     * if (extraction.status === 'completed') {
+     *   console.log(extraction.markdown);
+     *   console.log(extraction.pageMetadata);
+     * }
+     * ```
+     */
+    get(request: GetExtractionRequest): Promise<ExtractionResult>;
+    /**
+     * List extractions with pagination and filters
+     *
+     * @example
+     * ```typescript
+     * const { items, nextCursor } = await extraction.list({
+     *   status: 'completed',
+     *   limit: 20,
+     * });
+     * ```
+     */
+    list(request?: ListExtractionsRequest): Promise<ListExtractionsResponse>;
+    /**
+     * Delete an extraction
+     *
+     * @example
+     * ```typescript
+     * await extraction.delete({ id: 'extraction-id' });
+     * ```
+     */
+    delete(request: GetExtractionRequest): Promise<{
+        success: boolean;
+    }>;
+    /**
+     * Extract content and wait for completion
+     *
+     * @example
+     * ```typescript
+     * const extraction = await extraction.extractAndWait({
+     *   url: 'https://example.com/article',
+     *   mode: 'markdown',
+     * });
+     * console.log(extraction.markdown);
+     * ```
+     */
+    extractAndWait(request: CreateExtractionRequest, options?: {
+        pollInterval?: number;
+        timeout?: number;
+    }): Promise<ExtractionResult>;
+    /**
+     * Create a batch extraction job for multiple URLs
+     *
+     * @example
+     * ```typescript
+     * const { id, totalUrls } = await extraction.batch({
+     *   urls: [
+     *     'https://example.com/article1',
+     *     'https://example.com/article2',
+     *   ],
+     *   config: { mode: 'markdown' },
+     * });
+     * ```
+     */
+    batch(request: CreateBatchExtractionsRequest): Promise<CreateBatchResponse>;
+    /**
+     * Get a batch job by ID
+     */
+    getBatchJob(request: GetBatchJobRequest): Promise<BatchExtractionJob>;
+    /**
+     * List batch jobs with pagination and filters
+     */
+    listBatchJobs(request?: ListBatchJobsRequest): Promise<ExtractionBatchJobsResponse>;
+    /**
+     * Cancel a batch job
+     */
+    cancelBatchJob(request: GetBatchJobRequest): Promise<{
+        success: boolean;
+    }>;
+    /**
+     * Create a batch extraction job and wait for completion
+     */
+    batchAndWait(request: CreateBatchExtractionsRequest, options?: {
+        pollInterval?: number;
+        timeout?: number;
+    }): Promise<BatchExtractionJob>;
+    /**
+     * Create a scheduled extraction job
+     *
+     * @example
+     * ```typescript
+     * const { id } = await extraction.createSchedule({
+     *   name: 'Daily price monitoring',
+     *   url: 'https://competitor.com/pricing',
+     *   frequency: 'daily',
+     *   config: { mode: 'schema', schema: { ... } },
+     * });
+     * ```
+     */
+    createSchedule(request: CreateExtractionScheduleRequest): Promise<CreateScheduleResponse>;
+    /**
+     * Update a schedule
+     */
+    updateSchedule(request: UpdateExtractionScheduleRequest): Promise<{
+        success: boolean;
+    }>;
+    /**
+     * Get a schedule by ID
+     */
+    getSchedule(request: GetScheduleRequest): Promise<ExtractionSchedule>;
+    /**
+     * List schedules with pagination and filters
+     */
+    listSchedules(request?: ListSchedulesRequest): Promise<ExtractionSchedulesResponse>;
+    /**
+     * Delete a schedule
+     */
+    deleteSchedule(request: GetScheduleRequest): Promise<{
+        success: boolean;
+    }>;
+    /**
+     * Toggle a schedule on or off
+     */
+    toggleSchedule(request: GetScheduleRequest): Promise<{
+        isActive: boolean;
+    }>;
+    /**
+     * Get usage statistics
+     *
+     * @example
+     * ```typescript
+     * const usage = await extraction.getUsage({
+     *   periodStart: '2024-01-01T00:00:00Z',
+     *   periodEnd: '2024-01-31T23:59:59Z',
+     * });
+     * console.log(`Extractions: ${usage.extractionsTotal}`);
+     * console.log(`Tokens used: ${usage.extractionTokensUsed}`);
+     * ```
+     */
+    getUsage(request?: GetUsageRequest): Promise<ExtractionUsage>;
+    private convertDates;
+    private convertBatchJobDates;
+    private convertScheduleDates;
+    private convertUsageDates;
+}
+
+export { type BatchExtractionJob, type CreateBatchExtractionsRequest, type CreateExtractionRequest, type CreateExtractionResponse, type CreateExtractionScheduleRequest, Extraction, type ExtractionBatchJobsResponse, type ExtractionMode, type ExtractionResult, type ExtractionSchedule, type ExtractionSchedulesResponse, type ExtractionStatus, type ExtractionUsage, type GetExtractionRequest, type GetUsageRequest, type ListExtractionsRequest, type ListExtractionsResponse, type PageMetadata, type UpdateExtractionScheduleRequest };