gthinking 1.2.1 → 2.1.1

package/dist/types/analysis.d.ts

@@ -1,54 +1,1539 @@
-import { SearchResult } from './search';
-export interface AnalysisRequest {
-    id: string;
-    content: string;
-    analysisTypes: AnalysisType[];
-    context?: string;
-    depth: 'surface' | 'moderate' | 'deep';
+/**
+ * Analysis Types for gthinking v2.0.0
+ * Types for content analysis functionality
+ */
+import { z } from 'zod';
+/**
+ * Analysis Type Enum
+ */
+export declare enum AnalysisType {
+    SENTIMENT = "sentiment",
+    ENTITY = "entity",
+    TOPIC = "topic",
+    KEYWORD = "keyword",
+    SUMMARY = "summary",
+    FACT_CHECK = "fact_check",
+    COMPARISON = "comparison",
+    TREND = "trend",
+    LANGUAGE = "language",
+    READABILITY = "readability"
 }
-export type AnalysisType = 'sentiment' | 'entity' | 'topic' | 'keyword' | 'summary' | 'fact_check' | 'comparison' | 'trend';
-export interface AnalysisResult {
-    id: string;
-    requestId: string;
-    type: AnalysisType;
-    findings: Finding[];
-    confidence: number;
-    processingTime: number;
-    timestamp: Date;
+/**
+ * Analysis Type Schema
+ */
+export declare const AnalysisTypeSchema: z.ZodNativeEnum<typeof AnalysisType>;
+/**
+ * Sentiment Type Enum
+ */
+export declare enum SentimentType {
+    POSITIVE = "positive",
+    NEGATIVE = "negative",
+    NEUTRAL = "neutral",
+    MIXED = "mixed"
 }
-export interface Finding {
-    id: string;
-    type: string;
-    value: unknown;
-    confidence: number;
-    evidence: Evidence[];
-    relatedFindings: string[];
+/**
+ * Sentiment Type Schema
+ */
+export declare const SentimentTypeSchema: z.ZodNativeEnum<typeof SentimentType>;
+/**
+ * Entity Type Enum
+ */
+export declare enum EntityType {
+    PERSON = "person",
+    ORGANIZATION = "organization",
+    LOCATION = "location",
+    PRODUCT = "product",
+    EVENT = "event",
+    CONCEPT = "concept",
+    DATE = "date",
+    MONEY = "money",
+    PERCENT = "percent"
 }
-export interface Evidence {
-    source: string;
-    excerpt: string;
-    location: string;
-    strength: number;
-}
-export interface ComparisonResult {
-    id: string;
-    subjects: string[];
-    similarities: ComparisonPoint[];
-    differences: ComparisonPoint[];
-    conclusion: string;
-    confidence: number;
-}
-export interface ComparisonPoint {
-    aspect: string;
-    values: Record<string, unknown>;
-    significance: number;
-}
-export interface FactCheckResult {
-    claim: string;
-    verdict: 'true' | 'false' | 'partially_true' | 'unverifiable';
-    confidence: number;
-    sources: SearchResult[];
-    explanation: string;
+/**
+ * Entity Type Schema
+ */
+export declare const EntityTypeSchema: z.ZodNativeEnum<typeof EntityType>;
+/**
+ * Analysis Request Schema
+ */
+export declare const AnalysisRequestSchema: z.ZodObject<{
+    content: z.ZodString;
+    types: z.ZodArray<z.ZodNativeEnum<typeof AnalysisType>, "many">;
+    options: z.ZodDefault<z.ZodObject<{
+        language: z.ZodDefault<z.ZodString>;
+        depth: z.ZodDefault<z.ZodEnum<["shallow", "medium", "deep"]>>;
+        includeRaw: z.ZodDefault<z.ZodBoolean>;
+        maxEntities: z.ZodDefault<z.ZodNumber>;
+        maxKeywords: z.ZodDefault<z.ZodNumber>;
+        maxTopics: z.ZodDefault<z.ZodNumber>;
+        summaryLength: z.ZodDefault<z.ZodEnum<["short", "medium", "long"]>>;
+    }, "strip", z.ZodTypeAny, {
+        depth?: "shallow" | "medium" | "deep";
+        language?: string;
+        includeRaw?: boolean;
+        maxEntities?: number;
+        maxKeywords?: number;
+        maxTopics?: number;
+        summaryLength?: "medium" | "short" | "long";
+    }, {
+        depth?: "shallow" | "medium" | "deep";
+        language?: string;
+        includeRaw?: boolean;
+        maxEntities?: number;
+        maxKeywords?: number;
+        maxTopics?: number;
+        summaryLength?: "medium" | "short" | "long";
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    options?: {
+        depth?: "shallow" | "medium" | "deep";
+        language?: string;
+        includeRaw?: boolean;
+        maxEntities?: number;
+        maxKeywords?: number;
+        maxTopics?: number;
+        summaryLength?: "medium" | "short" | "long";
+    };
+    content?: string;
+    types?: AnalysisType[];
+}, {
+    options?: {
+        depth?: "shallow" | "medium" | "deep";
+        language?: string;
+        includeRaw?: boolean;
+        maxEntities?: number;
+        maxKeywords?: number;
+        maxTopics?: number;
+        summaryLength?: "medium" | "short" | "long";
+    };
+    content?: string;
+    types?: AnalysisType[];
+}>;
+/**
+ * Analysis Request Type
+ */
+export type AnalysisRequest = z.infer<typeof AnalysisRequestSchema>;
+/**
+ * Sentiment Result Schema
+ */
+export declare const SentimentResultSchema: z.ZodObject<{
+    overall: z.ZodNativeEnum<typeof SentimentType>;
+    score: z.ZodNumber;
+    confidence: z.ZodNumber;
+    aspects: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        aspect: z.ZodString;
+        sentiment: z.ZodNativeEnum<typeof SentimentType>;
+        score: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        sentiment?: SentimentType;
+        score?: number;
+        aspect?: string;
+    }, {
+        sentiment?: SentimentType;
+        score?: number;
+        aspect?: string;
+    }>, "many">>;
+    emotions: z.ZodDefault<z.ZodObject<{
+        joy: z.ZodDefault<z.ZodNumber>;
+        sadness: z.ZodDefault<z.ZodNumber>;
+        anger: z.ZodDefault<z.ZodNumber>;
+        fear: z.ZodDefault<z.ZodNumber>;
+        surprise: z.ZodDefault<z.ZodNumber>;
+        disgust: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        joy?: number;
+        sadness?: number;
+        anger?: number;
+        fear?: number;
+        surprise?: number;
+        disgust?: number;
+    }, {
+        joy?: number;
+        sadness?: number;
+        anger?: number;
+        fear?: number;
+        surprise?: number;
+        disgust?: number;
+    }>>;
+}, "strip", z.ZodTypeAny, {
+    confidence?: number;
+    overall?: SentimentType;
+    score?: number;
+    aspects?: {
+        sentiment?: SentimentType;
+        score?: number;
+        aspect?: string;
+    }[];
+    emotions?: {
+        joy?: number;
+        sadness?: number;
+        anger?: number;
+        fear?: number;
+        surprise?: number;
+        disgust?: number;
+    };
+}, {
+    confidence?: number;
+    overall?: SentimentType;
+    score?: number;
+    aspects?: {
+        sentiment?: SentimentType;
+        score?: number;
+        aspect?: string;
+    }[];
+    emotions?: {
+        joy?: number;
+        sadness?: number;
+        anger?: number;
+        fear?: number;
+        surprise?: number;
+        disgust?: number;
+    };
+}>;
+/**
+ * Sentiment Result Type
+ */
+export type SentimentResult = z.infer<typeof SentimentResultSchema>;
+/**
+ * Entity Schema
+ */
+export declare const EntitySchema: z.ZodObject<{
+    id: z.ZodString;
+    text: z.ZodString;
+    type: z.ZodNativeEnum<typeof EntityType>;
+    startIndex: z.ZodNumber;
+    endIndex: z.ZodNumber;
+    confidence: z.ZodNumber;
+    normalized: z.ZodOptional<z.ZodString>;
+    metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, "strip", z.ZodTypeAny, {
+    type?: EntityType;
+    confidence?: number;
+    id?: string;
+    metadata?: Record<string, unknown>;
+    text?: string;
+    startIndex?: number;
+    endIndex?: number;
+    normalized?: string;
+}, {
+    type?: EntityType;
+    confidence?: number;
+    id?: string;
+    metadata?: Record<string, unknown>;
+    text?: string;
+    startIndex?: number;
+    endIndex?: number;
+    normalized?: string;
+}>;
+/**
+ * Entity Type
+ */
+export type Entity = z.infer<typeof EntitySchema>;
+/**
+ * Entity Extraction Result Schema
+ */
+export declare const EntityExtractionResultSchema: z.ZodObject<{
+    entities: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        text: z.ZodString;
+        type: z.ZodNativeEnum<typeof EntityType>;
+        startIndex: z.ZodNumber;
+        endIndex: z.ZodNumber;
+        confidence: z.ZodNumber;
+        normalized: z.ZodOptional<z.ZodString>;
+        metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, "strip", z.ZodTypeAny, {
+        type?: EntityType;
+        confidence?: number;
+        id?: string;
+        metadata?: Record<string, unknown>;
+        text?: string;
+        startIndex?: number;
+        endIndex?: number;
+        normalized?: string;
+    }, {
+        type?: EntityType;
+        confidence?: number;
+        id?: string;
+        metadata?: Record<string, unknown>;
+        text?: string;
+        startIndex?: number;
+        endIndex?: number;
+        normalized?: string;
+    }>, "many">;
+    totalCount: z.ZodNumber;
+    byType: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+}, "strip", z.ZodTypeAny, {
+    entities?: {
+        type?: EntityType;
+        confidence?: number;
+        id?: string;
+        metadata?: Record<string, unknown>;
+        text?: string;
+        startIndex?: number;
+        endIndex?: number;
+        normalized?: string;
+    }[];
+    totalCount?: number;
+    byType?: Record<string, number>;
+}, {
+    entities?: {
+        type?: EntityType;
+        confidence?: number;
+        id?: string;
+        metadata?: Record<string, unknown>;
+        text?: string;
+        startIndex?: number;
+        endIndex?: number;
+        normalized?: string;
+    }[];
+    totalCount?: number;
+    byType?: Record<string, number>;
+}>;
+/**
+ * Entity Extraction Result Type
+ */
+export type EntityExtractionResult = z.infer<typeof EntityExtractionResultSchema>;
+/**
+ * Topic Schema
+ */
+export declare const TopicSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    confidence: z.ZodNumber;
+    keywords: z.ZodArray<z.ZodString, "many">;
+    relevance: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    confidence?: number;
+    name?: string;
+    id?: string;
+    relevance?: number;
+    keywords?: string[];
+}, {
+    confidence?: number;
+    name?: string;
+    id?: string;
+    relevance?: number;
+    keywords?: string[];
+}>;
+/**
+ * Topic Type
+ */
+export type Topic = z.infer<typeof TopicSchema>;
+/**
+ * Topic Extraction Result Schema
+ */
+export declare const TopicExtractionResultSchema: z.ZodObject<{
+    topics: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        confidence: z.ZodNumber;
+        keywords: z.ZodArray<z.ZodString, "many">;
+        relevance: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        confidence?: number;
+        name?: string;
+        id?: string;
+        relevance?: number;
+        keywords?: string[];
+    }, {
+        confidence?: number;
+        name?: string;
+        id?: string;
+        relevance?: number;
+        keywords?: string[];
+    }>, "many">;
+    mainTopic: z.ZodOptional<z.ZodString>;
+    topicHierarchy: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        parent: z.ZodString;
+        children: z.ZodArray<z.ZodString, "many">;
+    }, "strip", z.ZodTypeAny, {
+        parent?: string;
+        children?: string[];
+    }, {
+        parent?: string;
+        children?: string[];
+    }>, "many">>;
+}, "strip", z.ZodTypeAny, {
+    topics?: {
+        confidence?: number;
+        name?: string;
+        id?: string;
+        relevance?: number;
+        keywords?: string[];
+    }[];
+    mainTopic?: string;
+    topicHierarchy?: {
+        parent?: string;
+        children?: string[];
+    }[];
+}, {
+    topics?: {
+        confidence?: number;
+        name?: string;
+        id?: string;
+        relevance?: number;
+        keywords?: string[];
+    }[];
+    mainTopic?: string;
+    topicHierarchy?: {
+        parent?: string;
+        children?: string[];
+    }[];
+}>;
+/**
+ * Topic Extraction Result Type
+ */
+export type TopicExtractionResult = z.infer<typeof TopicExtractionResultSchema>;
+/**
+ * Keyword Schema
+ */
+export declare const KeywordSchema: z.ZodObject<{
+    text: z.ZodString;
+    score: z.ZodNumber;
+    frequency: z.ZodNumber;
+    tfidf: z.ZodNumber;
+    isKeyPhrase: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    score?: number;
+    text?: string;
+    frequency?: number;
+    tfidf?: number;
+    isKeyPhrase?: boolean;
+}, {
+    score?: number;
+    text?: string;
+    frequency?: number;
+    tfidf?: number;
+    isKeyPhrase?: boolean;
+}>;
+/**
+ * Keyword Type
+ */
+export type Keyword = z.infer<typeof KeywordSchema>;
+/**
+ * Keyword Extraction Result Schema
+ */
+export declare const KeywordExtractionResultSchema: z.ZodObject<{
+    keywords: z.ZodArray<z.ZodObject<{
+        text: z.ZodString;
+        score: z.ZodNumber;
+        frequency: z.ZodNumber;
+        tfidf: z.ZodNumber;
+        isKeyPhrase: z.ZodDefault<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        score?: number;
+        text?: string;
+        frequency?: number;
+        tfidf?: number;
+        isKeyPhrase?: boolean;
+    }, {
+        score?: number;
+        text?: string;
+        frequency?: number;
+        tfidf?: number;
+        isKeyPhrase?: boolean;
+    }>, "many">;
+    keyPhrases: z.ZodArray<z.ZodString, "many">;
+    totalWords: z.ZodNumber;
+    uniqueWords: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    keywords?: {
+        score?: number;
+        text?: string;
+        frequency?: number;
+        tfidf?: number;
+        isKeyPhrase?: boolean;
+    }[];
+    keyPhrases?: string[];
+    totalWords?: number;
+    uniqueWords?: number;
+}, {
+    keywords?: {
+        score?: number;
+        text?: string;
+        frequency?: number;
+        tfidf?: number;
+        isKeyPhrase?: boolean;
+    }[];
+    keyPhrases?: string[];
+    totalWords?: number;
+    uniqueWords?: number;
+}>;
+/**
+ * Keyword Extraction Result Type
+ */
+export type KeywordExtractionResult = z.infer<typeof KeywordExtractionResultSchema>;
+/**
+ * Summary Result Schema
+ */
+export declare const SummaryResultSchema: z.ZodObject<{
+    summary: z.ZodString;
+    keyPoints: z.ZodArray<z.ZodString, "many">;
+    originalLength: z.ZodNumber;
+    summaryLength: z.ZodNumber;
+    compressionRatio: z.ZodNumber;
+    method: z.ZodDefault<z.ZodEnum<["extractive", "abstractive", "hybrid"]>>;
+}, "strip", z.ZodTypeAny, {
+    summary?: string;
+    summaryLength?: number;
+    keyPoints?: string[];
+    originalLength?: number;
+    compressionRatio?: number;
+    method?: "extractive" | "abstractive" | "hybrid";
+}, {
+    summary?: string;
+    summaryLength?: number;
+    keyPoints?: string[];
+    originalLength?: number;
+    compressionRatio?: number;
+    method?: "extractive" | "abstractive" | "hybrid";
+}>;
+/**
+ * Summary Result Type
+ */
+export type SummaryResult = z.infer<typeof SummaryResultSchema>;
+/**
+ * Fact Check Result Schema
+ */
+export declare const FactCheckResultSchema: z.ZodObject<{
+    claim: z.ZodString;
+    verdict: z.ZodEnum<["true", "false", "partially_true", "unverifiable", "misleading"]>;
+    confidence: z.ZodNumber;
+    explanation: z.ZodString;
+    sources: z.ZodArray<z.ZodObject<{
+        url: z.ZodString;
+        title: z.ZodString;
+        credibility: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        title?: string;
+        url?: string;
+        credibility?: number;
+    }, {
+        title?: string;
+        url?: string;
+        credibility?: number;
+    }>, "many">;
+    corrections: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    confidence?: number;
+    sources?: {
+        title?: string;
+        url?: string;
+        credibility?: number;
+    }[];
+    claim?: string;
+    verdict?: "true" | "false" | "partially_true" | "unverifiable" | "misleading";
+    explanation?: string;
     corrections?: string[];
-}
+}, {
+    confidence?: number;
+    sources?: {
+        title?: string;
+        url?: string;
+        credibility?: number;
+    }[];
+    claim?: string;
+    verdict?: "true" | "false" | "partially_true" | "unverifiable" | "misleading";
+    explanation?: string;
+    corrections?: string[];
+}>;
+/**
+ * Fact Check Result Type
+ */
+export type FactCheckResult = z.infer<typeof FactCheckResultSchema>;
+/**
+ * Comparison Result Schema
+ */
+export declare const ComparisonResultSchema: z.ZodObject<{
+    subjects: z.ZodArray<z.ZodString, "many">;
+    similarities: z.ZodArray<z.ZodString, "many">;
+    differences: z.ZodArray<z.ZodString, "many">;
+    similarityScore: z.ZodNumber;
+    aspects: z.ZodArray<z.ZodObject<{
+        aspect: z.ZodString;
+        subject1Value: z.ZodString;
+        subject2Value: z.ZodString;
+        comparison: z.ZodEnum<["better", "worse", "equal", "different"]>;
+    }, "strip", z.ZodTypeAny, {
+        comparison?: "better" | "worse" | "equal" | "different";
+        aspect?: string;
+        subject1Value?: string;
+        subject2Value?: string;
+    }, {
+        comparison?: "better" | "worse" | "equal" | "different";
+        aspect?: string;
+        subject1Value?: string;
+        subject2Value?: string;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    aspects?: {
+        comparison?: "better" | "worse" | "equal" | "different";
+        aspect?: string;
+        subject1Value?: string;
+        subject2Value?: string;
+    }[];
+    subjects?: string[];
+    similarities?: string[];
+    differences?: string[];
+    similarityScore?: number;
+}, {
+    aspects?: {
+        comparison?: "better" | "worse" | "equal" | "different";
+        aspect?: string;
+        subject1Value?: string;
+        subject2Value?: string;
+    }[];
+    subjects?: string[];
+    similarities?: string[];
+    differences?: string[];
+    similarityScore?: number;
+}>;
+/**
+ * Comparison Result Type
+ */
+export type ComparisonResult = z.infer<typeof ComparisonResultSchema>;
+/**
+ * Language Detection Result Schema
+ */
+export declare const LanguageDetectionResultSchema: z.ZodObject<{
+    language: z.ZodString;
+    confidence: z.ZodNumber;
+    alternatives: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        language: z.ZodString;
+        confidence: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        confidence?: number;
+        language?: string;
+    }, {
+        confidence?: number;
+        language?: string;
+    }>, "many">>;
+}, "strip", z.ZodTypeAny, {
+    confidence?: number;
+    language?: string;
+    alternatives?: {
+        confidence?: number;
+        language?: string;
+    }[];
+}, {
+    confidence?: number;
+    language?: string;
+    alternatives?: {
+        confidence?: number;
+        language?: string;
+    }[];
+}>;
+/**
+ * Language Detection Result Type
+ */
+export type LanguageDetectionResult = z.infer<typeof LanguageDetectionResultSchema>;
+/**
+ * Readability Result Schema
+ */
+export declare const ReadabilityResultSchema: z.ZodObject<{
+    score: z.ZodNumber;
+    grade: z.ZodEnum<["elementary", "middle_school", "high_school", "college", "graduate"]>;
+    metrics: z.ZodObject<{
+        fleschKincaid: z.ZodNumber;
+        fleschReadingEase: z.ZodNumber;
+        gunningFog: z.ZodNumber;
+        smogIndex: z.ZodNumber;
+        colemanLiau: z.ZodNumber;
+        automatedReadability: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        fleschKincaid?: number;
+        fleschReadingEase?: number;
+        gunningFog?: number;
+        smogIndex?: number;
+        colemanLiau?: number;
+        automatedReadability?: number;
+    }, {
+        fleschKincaid?: number;
+        fleschReadingEase?: number;
+        gunningFog?: number;
+        smogIndex?: number;
+        colemanLiau?: number;
+        automatedReadability?: number;
+    }>;
+    statistics: z.ZodObject<{
+        wordCount: z.ZodNumber;
+        sentenceCount: z.ZodNumber;
+        syllableCount: z.ZodNumber;
+        avgWordsPerSentence: z.ZodNumber;
+        avgSyllablesPerWord: z.ZodNumber;
+        complexWordCount: z.ZodNumber;
+        complexWordPercentage: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        wordCount?: number;
+        sentenceCount?: number;
+        syllableCount?: number;
+        avgWordsPerSentence?: number;
+        avgSyllablesPerWord?: number;
+        complexWordCount?: number;
+        complexWordPercentage?: number;
+    }, {
+        wordCount?: number;
+        sentenceCount?: number;
+        syllableCount?: number;
+        avgWordsPerSentence?: number;
+        avgSyllablesPerWord?: number;
+        complexWordCount?: number;
+        complexWordPercentage?: number;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    score?: number;
+    grade?: "elementary" | "middle_school" | "high_school" | "college" | "graduate";
+    metrics?: {
+        fleschKincaid?: number;
+        fleschReadingEase?: number;
+        gunningFog?: number;
+        smogIndex?: number;
+        colemanLiau?: number;
+        automatedReadability?: number;
+    };
+    statistics?: {
+        wordCount?: number;
+        sentenceCount?: number;
+        syllableCount?: number;
+        avgWordsPerSentence?: number;
+        avgSyllablesPerWord?: number;
+        complexWordCount?: number;
+        complexWordPercentage?: number;
+    };
+}, {
+    score?: number;
+    grade?: "elementary" | "middle_school" | "high_school" | "college" | "graduate";
+    metrics?: {
+        fleschKincaid?: number;
+        fleschReadingEase?: number;
+        gunningFog?: number;
+        smogIndex?: number;
+        colemanLiau?: number;
+        automatedReadability?: number;
+    };
+    statistics?: {
+        wordCount?: number;
+        sentenceCount?: number;
+        syllableCount?: number;
+        avgWordsPerSentence?: number;
+        avgSyllablesPerWord?: number;
+        complexWordCount?: number;
+        complexWordPercentage?: number;
+    };
+}>;
+/**
+ * Readability Result Type
+ */
+export type ReadabilityResult = z.infer<typeof ReadabilityResultSchema>;
+/**
+ * Complete Analysis Result Schema
+ */
+export declare const CompleteAnalysisResultSchema: z.ZodObject<{
+    success: z.ZodBoolean;
+    confidence: z.ZodNumber;
+    timestamp: z.ZodDate;
+    duration: z.ZodNumber;
+    errors: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+} & {
+    request: z.ZodObject<{
+        content: z.ZodString;
+        types: z.ZodArray<z.ZodNativeEnum<typeof AnalysisType>, "many">;
+        options: z.ZodDefault<z.ZodObject<{
+            language: z.ZodDefault<z.ZodString>;
+            depth: z.ZodDefault<z.ZodEnum<["shallow", "medium", "deep"]>>;
+            includeRaw: z.ZodDefault<z.ZodBoolean>;
+            maxEntities: z.ZodDefault<z.ZodNumber>;
+            maxKeywords: z.ZodDefault<z.ZodNumber>;
+            maxTopics: z.ZodDefault<z.ZodNumber>;
+            summaryLength: z.ZodDefault<z.ZodEnum<["short", "medium", "long"]>>;
+        }, "strip", z.ZodTypeAny, {
+            depth?: "shallow" | "medium" | "deep";
+            language?: string;
+            includeRaw?: boolean;
+            maxEntities?: number;
+            maxKeywords?: number;
+            maxTopics?: number;
+            summaryLength?: "medium" | "short" | "long";
+        }, {
+            depth?: "shallow" | "medium" | "deep";
+            language?: string;
+            includeRaw?: boolean;
+            maxEntities?: number;
+            maxKeywords?: number;
+            maxTopics?: number;
+            summaryLength?: "medium" | "short" | "long";
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        options?: {
+            depth?: "shallow" | "medium" | "deep";
+            language?: string;
+            includeRaw?: boolean;
+            maxEntities?: number;
+            maxKeywords?: number;
+            maxTopics?: number;
+            summaryLength?: "medium" | "short" | "long";
+        };
+        content?: string;
+        types?: AnalysisType[];
+    }, {
+        options?: {
+            depth?: "shallow" | "medium" | "deep";
+            language?: string;
+            includeRaw?: boolean;
+            maxEntities?: number;
+            maxKeywords?: number;
+            maxTopics?: number;
+            summaryLength?: "medium" | "short" | "long";
+        };
+        content?: string;
+        types?: AnalysisType[];
+    }>;
+    sentiment: z.ZodOptional<z.ZodObject<{
+        overall: z.ZodNativeEnum<typeof SentimentType>;
+        score: z.ZodNumber;
+        confidence: z.ZodNumber;
+        aspects: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            aspect: z.ZodString;
+            sentiment: z.ZodNativeEnum<typeof SentimentType>;
+            score: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            sentiment?: SentimentType;
+            score?: number;
+            aspect?: string;
+        }, {
+            sentiment?: SentimentType;
+            score?: number;
+            aspect?: string;
+        }>, "many">>;
+        emotions: z.ZodDefault<z.ZodObject<{
+            joy: z.ZodDefault<z.ZodNumber>;
+            sadness: z.ZodDefault<z.ZodNumber>;
+            anger: z.ZodDefault<z.ZodNumber>;
+            fear: z.ZodDefault<z.ZodNumber>;
+            surprise: z.ZodDefault<z.ZodNumber>;
+            disgust: z.ZodDefault<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            joy?: number;
+            sadness?: number;
+            anger?: number;
+            fear?: number;
+            surprise?: number;
+            disgust?: number;
+        }, {
+            joy?: number;
+            sadness?: number;
+            anger?: number;
+            fear?: number;
+            surprise?: number;
+            disgust?: number;
+        }>>;
+    }, "strip", z.ZodTypeAny, {
+        confidence?: number;
+        overall?: SentimentType;
+        score?: number;
+        aspects?: {
+            sentiment?: SentimentType;
+            score?: number;
+            aspect?: string;
+        }[];
+        emotions?: {
+            joy?: number;
+            sadness?: number;
+            anger?: number;
+            fear?: number;
+            surprise?: number;
+            disgust?: number;
+        };
+    }, {
+        confidence?: number;
+        overall?: SentimentType;
+        score?: number;
+        aspects?: {
+            sentiment?: SentimentType;
+            score?: number;
+            aspect?: string;
+        }[];
+        emotions?: {
+            joy?: number;
+            sadness?: number;
+            anger?: number;
+            fear?: number;
+            surprise?: number;
+            disgust?: number;
+        };
+    }>>;
+    entities: z.ZodOptional<z.ZodObject<{
+        entities: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            text: z.ZodString;
+            type: z.ZodNativeEnum<typeof EntityType>;
+            startIndex: z.ZodNumber;
+            endIndex: z.ZodNumber;
+            confidence: z.ZodNumber;
+            normalized: z.ZodOptional<z.ZodString>;
+            metadata: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, "strip", z.ZodTypeAny, {
+            type?: EntityType;
+            confidence?: number;
+            id?: string;
+            metadata?: Record<string, unknown>;
+            text?: string;
+            startIndex?: number;
+            endIndex?: number;
+            normalized?: string;
+        }, {
+            type?: EntityType;
+            confidence?: number;
+            id?: string;
+            metadata?: Record<string, unknown>;
+            text?: string;
+            startIndex?: number;
+            endIndex?: number;
+            normalized?: string;
+        }>, "many">;
+        totalCount: z.ZodNumber;
+        byType: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+    }, "strip", z.ZodTypeAny, {
+        entities?: {
+            type?: EntityType;
+            confidence?: number;
+            id?: string;
+            metadata?: Record<string, unknown>;
+            text?: string;
+            startIndex?: number;
+            endIndex?: number;
+            normalized?: string;
+        }[];
+        totalCount?: number;
+        byType?: Record<string, number>;
+    }, {
+        entities?: {
+            type?: EntityType;
+            confidence?: number;
+            id?: string;
+            metadata?: Record<string, unknown>;
+            text?: string;
+            startIndex?: number;
+            endIndex?: number;
+            normalized?: string;
+        }[];
+        totalCount?: number;
+        byType?: Record<string, number>;
+    }>>;
+    topics: z.ZodOptional<z.ZodObject<{
+        topics: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+            confidence: z.ZodNumber;
+            keywords: z.ZodArray<z.ZodString, "many">;
+            relevance: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            confidence?: number;
+            name?: string;
+            id?: string;
+            relevance?: number;
+            keywords?: string[];
+        }, {
+            confidence?: number;
+            name?: string;
+            id?: string;
+            relevance?: number;
+            keywords?: string[];
+        }>, "many">;
+        mainTopic: z.ZodOptional<z.ZodString>;
+        topicHierarchy: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            parent: z.ZodString;
+            children: z.ZodArray<z.ZodString, "many">;
+        }, "strip", z.ZodTypeAny, {
+            parent?: string;
+            children?: string[];
+        }, {
+            parent?: string;
+            children?: string[];
+        }>, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        topics?: {
+            confidence?: number;
+            name?: string;
+            id?: string;
+            relevance?: number;
+            keywords?: string[];
+        }[];
+        mainTopic?: string;
+        topicHierarchy?: {
+            parent?: string;
+            children?: string[];
+        }[];
+    }, {
+        topics?: {
+            confidence?: number;
+            name?: string;
+            id?: string;
+            relevance?: number;
+            keywords?: string[];
+        }[];
+        mainTopic?: string;
+        topicHierarchy?: {
+            parent?: string;
+            children?: string[];
+        }[];
+    }>>;
+    keywords: z.ZodOptional<z.ZodObject<{
+        keywords: z.ZodArray<z.ZodObject<{
+            text: z.ZodString;
+            score: z.ZodNumber;
+            frequency: z.ZodNumber;
+            tfidf: z.ZodNumber;
+            isKeyPhrase: z.ZodDefault<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            score?: number;
+            text?: string;
+            frequency?: number;
+            tfidf?: number;
+            isKeyPhrase?: boolean;
+        }, {
+            score?: number;
+            text?: string;
+            frequency?: number;
+            tfidf?: number;
+            isKeyPhrase?: boolean;
+        }>, "many">;
+        keyPhrases: z.ZodArray<z.ZodString, "many">;
+        totalWords: z.ZodNumber;
+        uniqueWords: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        keywords?: {
+            score?: number;
+            text?: string;
+            frequency?: number;
+            tfidf?: number;
+            isKeyPhrase?: boolean;
+        }[];
+        keyPhrases?: string[];
+        totalWords?: number;
+        uniqueWords?: number;
+    }, {
+        keywords?: {
+            score?: number;
+            text?: string;
+            frequency?: number;
+            tfidf?: number;
+            isKeyPhrase?: boolean;
+        }[];
+        keyPhrases?: string[];
+        totalWords?: number;
+        uniqueWords?: number;
+    }>>;
+    summary: z.ZodOptional<z.ZodObject<{
+        summary: z.ZodString;
+        keyPoints: z.ZodArray<z.ZodString, "many">;
+        originalLength: z.ZodNumber;
+        summaryLength: z.ZodNumber;
+        compressionRatio: z.ZodNumber;
+        method: z.ZodDefault<z.ZodEnum<["extractive", "abstractive", "hybrid"]>>;
+    }, "strip", z.ZodTypeAny, {
+        summary?: string;
+        summaryLength?: number;
+        keyPoints?: string[];
+        originalLength?: number;
+        compressionRatio?: number;
+        method?: "extractive" | "abstractive" | "hybrid";
+    }, {
+        summary?: string;
+        summaryLength?: number;
+        keyPoints?: string[];
+        originalLength?: number;
+        compressionRatio?: number;
+        method?: "extractive" | "abstractive" | "hybrid";
+    }>>;
+    factChecks: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        claim: z.ZodString;
+        verdict: z.ZodEnum<["true", "false", "partially_true", "unverifiable", "misleading"]>;
+        confidence: z.ZodNumber;
+        explanation: z.ZodString;
+        sources: z.ZodArray<z.ZodObject<{
+            url: z.ZodString;
+            title: z.ZodString;
+            credibility: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            title?: string;
+            url?: string;
+            credibility?: number;
+        }, {
+            title?: string;
+            url?: string;
+            credibility?: number;
+        }>, "many">;
+        corrections: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        confidence?: number;
+        sources?: {
+            title?: string;
+            url?: string;
+            credibility?: number;
+        }[];
+        claim?: string;
+        verdict?: "true" | "false" | "partially_true" | "unverifiable" | "misleading";
+        explanation?: string;
+        corrections?: string[];
+    }, {
+        confidence?: number;
+        sources?: {
+            title?: string;
+            url?: string;
+            credibility?: number;
+        }[];
+        claim?: string;
+        verdict?: "true" | "false" | "partially_true" | "unverifiable" | "misleading";
+        explanation?: string;
+        corrections?: string[];
+    }>, "many">>;
+    comparison: z.ZodOptional<z.ZodObject<{
+        subjects: z.ZodArray<z.ZodString, "many">;
+        similarities: z.ZodArray<z.ZodString, "many">;
+        differences: z.ZodArray<z.ZodString, "many">;
+        similarityScore: z.ZodNumber;
+        aspects: z.ZodArray<z.ZodObject<{
+            aspect: z.ZodString;
+            subject1Value: z.ZodString;
+            subject2Value: z.ZodString;
+            comparison: z.ZodEnum<["better", "worse", "equal", "different"]>;
+        }, "strip", z.ZodTypeAny, {
+            comparison?: "better" | "worse" | "equal" | "different";
+            aspect?: string;
+            subject1Value?: string;
+            subject2Value?: string;
+        }, {
+            comparison?: "better" | "worse" | "equal" | "different";
+            aspect?: string;
+            subject1Value?: string;
+            subject2Value?: string;
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        aspects?: {
+            comparison?: "better" | "worse" | "equal" | "different";
+            aspect?: string;
+            subject1Value?: string;
+            subject2Value?: string;
+        }[];
+        subjects?: string[];
+        similarities?: string[];
+        differences?: string[];
+        similarityScore?: number;
+    }, {
+        aspects?: {
+            comparison?: "better" | "worse" | "equal" | "different";
+            aspect?: string;
+            subject1Value?: string;
+            subject2Value?: string;
+        }[];
+        subjects?: string[];
+        similarities?: string[];
+        differences?: string[];
+        similarityScore?: number;
+    }>>;
+    language: z.ZodOptional<z.ZodObject<{
+        language: z.ZodString;
+        confidence: z.ZodNumber;
+        alternatives: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            language: z.ZodString;
+            confidence: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            confidence?: number;
+            language?: string;
+        }, {
+            confidence?: number;
+            language?: string;
+        }>, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        confidence?: number;
+        language?: string;
+        alternatives?: {
+            confidence?: number;
+            language?: string;
+        }[];
+    }, {
+        confidence?: number;
+        language?: string;
+        alternatives?: {
+            confidence?: number;
+            language?: string;
+        }[];
+    }>>;
+    readability: z.ZodOptional<z.ZodObject<{
+        score: z.ZodNumber;
+        grade: z.ZodEnum<["elementary", "middle_school", "high_school", "college", "graduate"]>;
+        metrics: z.ZodObject<{
+            fleschKincaid: z.ZodNumber;
+            fleschReadingEase: z.ZodNumber;
+            gunningFog: z.ZodNumber;
+            smogIndex: z.ZodNumber;
+            colemanLiau: z.ZodNumber;
+            automatedReadability: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            fleschKincaid?: number;
+            fleschReadingEase?: number;
+            gunningFog?: number;
+            smogIndex?: number;
+            colemanLiau?: number;
+            automatedReadability?: number;
+        }, {
+            fleschKincaid?: number;
+            fleschReadingEase?: number;
+            gunningFog?: number;
+            smogIndex?: number;
+            colemanLiau?: number;
+            automatedReadability?: number;
+        }>;
+        statistics: z.ZodObject<{
+            wordCount: z.ZodNumber;
+            sentenceCount: z.ZodNumber;
+            syllableCount: z.ZodNumber;
+            avgWordsPerSentence: z.ZodNumber;
+            avgSyllablesPerWord: z.ZodNumber;
+            complexWordCount: z.ZodNumber;
+            complexWordPercentage: z.ZodNumber;
+        }, "strip", z.ZodTypeAny, {
+            wordCount?: number;
+            sentenceCount?: number;
+            syllableCount?: number;
+            avgWordsPerSentence?: number;
+            avgSyllablesPerWord?: number;
+            complexWordCount?: number;
+            complexWordPercentage?: number;
+        }, {
+            wordCount?: number;
+            sentenceCount?: number;
+            syllableCount?: number;
+            avgWordsPerSentence?: number;
+            avgSyllablesPerWord?: number;
+            complexWordCount?: number;
+            complexWordPercentage?: number;
+        }>;
+    }, "strip", z.ZodTypeAny, {
+        score?: number;
+        grade?: "elementary" | "middle_school" | "high_school" | "college" | "graduate";
+        metrics?: {
+            fleschKincaid?: number;
+            fleschReadingEase?: number;
+            gunningFog?: number;
+            smogIndex?: number;
+            colemanLiau?: number;
+            automatedReadability?: number;
+        };
+        statistics?: {
+            wordCount?: number;
+            sentenceCount?: number;
+            syllableCount?: number;
+            avgWordsPerSentence?: number;
+            avgSyllablesPerWord?: number;
+            complexWordCount?: number;
+            complexWordPercentage?: number;
+        };
+    }, {
+        score?: number;
+        grade?: "elementary" | "middle_school" | "high_school" | "college" | "graduate";
+        metrics?: {
+            fleschKincaid?: number;
+            fleschReadingEase?: number;
+            gunningFog?: number;
+            smogIndex?: number;
+            colemanLiau?: number;
+            automatedReadability?: number;
+        };
+        statistics?: {
+            wordCount?: number;
+            sentenceCount?: number;
+            syllableCount?: number;
+            avgWordsPerSentence?: number;
+            avgSyllablesPerWord?: number;
+            complexWordCount?: number;
+            complexWordPercentage?: number;
+        };
+    }>>;
+    rawContent: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    success?: boolean;
+    confidence?: number;
+    timestamp?: Date;
+    duration?: number;
+    errors?: string[];
+    language?: {
+        confidence?: number;
+        language?: string;
+        alternatives?: {
+            confidence?: number;
+            language?: string;
+        }[];
+    };
+    summary?: {
+        summary?: string;
+        summaryLength?: number;
+        keyPoints?: string[];
+        originalLength?: number;
+        compressionRatio?: number;
+        method?: "extractive" | "abstractive" | "hybrid";
+    };
+    sentiment?: {
+        confidence?: number;
+        overall?: SentimentType;
+        score?: number;
+        aspects?: {
+            sentiment?: SentimentType;
+            score?: number;
+            aspect?: string;
+        }[];
+        emotions?: {
+            joy?: number;
+            sadness?: number;
+            anger?: number;
+            fear?: number;
+            surprise?: number;
+            disgust?: number;
+        };
+    };
+    comparison?: {
+        aspects?: {
+            comparison?: "better" | "worse" | "equal" | "different";
+            aspect?: string;
+            subject1Value?: string;
+            subject2Value?: string;
+        }[];
+        subjects?: string[];
+        similarities?: string[];
+        differences?: string[];
+        similarityScore?: number;
+    };
+    readability?: {
+        score?: number;
+        grade?: "elementary" | "middle_school" | "high_school" | "college" | "graduate";
+        metrics?: {
+            fleschKincaid?: number;
+            fleschReadingEase?: number;
+            gunningFog?: number;
+            smogIndex?: number;
+            colemanLiau?: number;
+            automatedReadability?: number;
+        };
+        statistics?: {
+            wordCount?: number;
+            sentenceCount?: number;
+            syllableCount?: number;
+            avgWordsPerSentence?: number;
+            avgSyllablesPerWord?: number;
+            complexWordCount?: number;
+            complexWordPercentage?: number;
+        };
+    };
+    entities?: {
+        entities?: {
+            type?: EntityType;
+            confidence?: number;
+            id?: string;
+            metadata?: Record<string, unknown>;
+            text?: string;
+            startIndex?: number;
+            endIndex?: number;
+            normalized?: string;
+        }[];
+        totalCount?: number;
+        byType?: Record<string, number>;
+    };
+    keywords?: {
+        keywords?: {
+            score?: number;
+            text?: string;
+            frequency?: number;
+            tfidf?: number;
+            isKeyPhrase?: boolean;
+        }[];
+        keyPhrases?: string[];
+        totalWords?: number;
+        uniqueWords?: number;
+    };
+    topics?: {
+        topics?: {
+            confidence?: number;
+            name?: string;
+            id?: string;
+            relevance?: number;
+            keywords?: string[];
+        }[];
+        mainTopic?: string;
+        topicHierarchy?: {
+            parent?: string;
+            children?: string[];
+        }[];
+    };
+    request?: {
+        options?: {
+            depth?: "shallow" | "medium" | "deep";
+            language?: string;
+            includeRaw?: boolean;
+            maxEntities?: number;
+            maxKeywords?: number;
+            maxTopics?: number;
+            summaryLength?: "medium" | "short" | "long";
+        };
+        content?: string;
+        types?: AnalysisType[];
+    };
+    factChecks?: {
+        confidence?: number;
+        sources?: {
+            title?: string;
+            url?: string;
+            credibility?: number;
+        }[];
+        claim?: string;
+        verdict?: "true" | "false" | "partially_true" | "unverifiable" | "misleading";
+        explanation?: string;
+        corrections?: string[];
+    }[];
+    rawContent?: string;
+}, {
+    success?: boolean;
+    confidence?: number;
+    timestamp?: Date;
+    duration?: number;
+    errors?: string[];
+    language?: {
+        confidence?: number;
+        language?: string;
+        alternatives?: {
+            confidence?: number;
+            language?: string;
+        }[];
+    };
+    summary?: {
+        summary?: string;
+        summaryLength?: number;
+        keyPoints?: string[];
+        originalLength?: number;
+        compressionRatio?: number;
+        method?: "extractive" | "abstractive" | "hybrid";
+    };
+    sentiment?: {
+        confidence?: number;
+        overall?: SentimentType;
+        score?: number;
+        aspects?: {
+            sentiment?: SentimentType;
+            score?: number;
+            aspect?: string;
+        }[];
+        emotions?: {
+            joy?: number;
+            sadness?: number;
+            anger?: number;
+            fear?: number;
+            surprise?: number;
+            disgust?: number;
+        };
+    };
+    comparison?: {
+        aspects?: {
+            comparison?: "better" | "worse" | "equal" | "different";
+            aspect?: string;
+            subject1Value?: string;
+            subject2Value?: string;
+        }[];
+        subjects?: string[];
+        similarities?: string[];
+        differences?: string[];
+        similarityScore?: number;
+    };
+    readability?: {
+        score?: number;
+        grade?: "elementary" | "middle_school" | "high_school" | "college" | "graduate";
+        metrics?: {
+            fleschKincaid?: number;
+            fleschReadingEase?: number;
+            gunningFog?: number;
+            smogIndex?: number;
+            colemanLiau?: number;
+            automatedReadability?: number;
+        };
+        statistics?: {
+            wordCount?: number;
+            sentenceCount?: number;
+            syllableCount?: number;
+            avgWordsPerSentence?: number;
+            avgSyllablesPerWord?: number;
+            complexWordCount?: number;
+            complexWordPercentage?: number;
+        };
+    };
+    entities?: {
+        entities?: {
+            type?: EntityType;
+            confidence?: number;
+            id?: string;
+            metadata?: Record<string, unknown>;
+            text?: string;
+            startIndex?: number;
+            endIndex?: number;
+            normalized?: string;
+        }[];
+        totalCount?: number;
+        byType?: Record<string, number>;
+    };
+    keywords?: {
+        keywords?: {
+            score?: number;
+            text?: string;
+            frequency?: number;
+            tfidf?: number;
+            isKeyPhrase?: boolean;
+        }[];
+        keyPhrases?: string[];
+        totalWords?: number;
+        uniqueWords?: number;
+    };
+    topics?: {
+        topics?: {
+            confidence?: number;
+            name?: string;
+            id?: string;
+            relevance?: number;
+            keywords?: string[];
+        }[];
+        mainTopic?: string;
+        topicHierarchy?: {
+            parent?: string;
+            children?: string[];
+        }[];
+    };
+    request?: {
+        options?: {
+            depth?: "shallow" | "medium" | "deep";
+            language?: string;
+            includeRaw?: boolean;
+            maxEntities?: number;
+            maxKeywords?: number;
+            maxTopics?: number;
+            summaryLength?: "medium" | "short" | "long";
+        };
+        content?: string;
+        types?: AnalysisType[];
+    };
+    factChecks?: {
+        confidence?: number;
+        sources?: {
+            title?: string;
+            url?: string;
+            credibility?: number;
+        }[];
+        claim?: string;
+        verdict?: "true" | "false" | "partially_true" | "unverifiable" | "misleading";
+        explanation?: string;
+        corrections?: string[];
+    }[];
+    rawContent?: string;
+}>;
+/**
+ * Complete Analysis Result Type
+ */
+export type CompleteAnalysisResult = z.infer<typeof CompleteAnalysisResultSchema>;
 //# sourceMappingURL=analysis.d.ts.map