import { createClient } from "@pdfvector/instance-client";

const client = createClient({
  apiKey: "your-api-key",
});

// Parse a document
const parseResult = await client.document.parse({
  url: "https://example.com/document.pdf",
});

console.log(parseResult.markdown);
console.log(`Pages: ${parseResult.pageCount}, Model: ${parseResult.model}`);

// Ask questions about documents
const askResult = await client.document.ask({
  url: "https://example.com/research-paper.pdf",
  question: "What are the key findings and conclusions?",
});

console.log(askResult.markdown);

// Extract structured data using JSON Schema
const extractResult = await client.document.extract({
  url: "https://example.com/research-paper.pdf",
  prompt: "Extract the research information",
  schema: {
    type: "object",
    properties: {
      title: { type: "string" },
      authors: { type: "array", items: { type: "string" } },
      abstract: { type: "string" },
      findings: { type: "array", items: { type: "string" } },
    },
    required: ["title", "abstract"],
  },
});

console.log(extractResult.data);

const client = createClient({
  apiKey: "your-api-key",
});

const status = await client.authenticate.validateCredential();
console.log(status.version); // Server version

const client = createClient({
  domain: "your-instance.pdfvector.com",
  apiKey: "your-api-key",
});

// For local development
const localClient = createClient({
  domain: "localhost:34000",
  apiKey: "your-api-key",
});

const result = await client.document.parse(
  {
    url: "https://example.com/document.pdf",
    model: "auto", // "auto" | "nano" | "mini" | "pro" | "max"
  },
  { context: { documentId: "my-doc-123" } }, // optional, for usage tracking
);

console.log(result.markdown);  // Extracted text
console.log(result.pageCount); // Number of pages
console.log(result.model);     // Model tier used
console.log(result.html);      // Full HTML (only with 'max' model)
console.log(result.documentId); // "my-doc-123"

import { readFile } from "fs/promises";

const result = await client.document.parse(
  {
    file: new File([await readFile("document.pdf")], "document.pdf", {
      type: "application/pdf",
    }),
    model: "auto",
  },
  { context: { documentId: "uploaded-doc" } },
);

console.log(result.markdown);

const result = await client.document.ask(
  {
    url: "https://example.com/research-paper.pdf",
    question: "What are the main findings of this study?",
    model: "auto",
  },
  { context: { documentId: "research-paper-1" } },
);

console.log(result.markdown);

const result = await client.document.extract(
  {
    url: "https://example.com/research-paper.pdf",
    prompt: "Extract the title, authors, and publication year",
    schema: {
      type: "object",
      properties: {
        title: { type: "string" },
        authors: { type: "array", items: { type: "string" } },
        year: { type: "number" },
      },
      required: ["title", "authors", "year"],
    },
  },
  { context: { documentId: "research-paper-1" } },
);

console.log(result.data); // { title: "...", authors: [...], year: 2024 }

const result = await client.invoice.parse(
  { url: "https://example.com/invoice.pdf" },
  { context: { documentId: "invoice-001" } },
);

console.log(result.markdown);

const result = await client.invoice.ask(
  {
    url: "https://example.com/invoice.pdf",
    question: "What is the total amount and due date for this invoice?",
  },
  { context: { documentId: "invoice-001" } },
);

console.log(result.markdown);

const result = await client.invoice.extract(
  {
    url: "https://example.com/invoice.pdf",
    prompt: "Extract all invoice details including vendor, items, and totals",
    schema: {
      type: "object",
      properties: {
        invoiceNumber: { type: "string" },
        date: { type: "string" },
        totalAmount: { type: "number" },
        items: {
          type: "array",
          items: {
            type: "object",
            properties: {
              description: { type: "string" },
              quantity: { type: "number" },
              price: { type: "number" },
            },
          },
        },
      },
      required: ["invoiceNumber", "date", "totalAmount", "items"],
    },
  },
  { context: { documentId: "invoice-001" } },
);

console.log(result.data);

const result = await client.identity.parse(
  { url: "https://example.com/passport.pdf" },
  { context: { documentId: "passport-jane" } },
);

console.log(result.markdown);
console.log(result.documentType); // e.g., "passport"

const result = await client.identity.ask(
  {
    url: "https://example.com/passport.pdf",
    question: "What is the full name and date of birth on this document?",
  },
  { context: { documentId: "passport-jane" } },
);

console.log(result.markdown);

const result = await client.identity.extract(
  {
    url: "https://example.com/passport.pdf",
    prompt: "Extract passport details from this document",
    schema: {
      type: "object",
      properties: {
        fullName: { type: "string" },
        dateOfBirth: { type: "string" },
        documentNumber: { type: "string" },
        nationality: { type: "string" },
        expirationDate: { type: "string" },
      },
      required: ["fullName", "documentNumber"],
    },
  },
  { context: { documentId: "passport-jane" } },
);

console.log(result.data);

const result = await client.bankStatement.parse(
  { url: "https://example.com/statement.pdf" },
  { context: { documentId: "statement-2024-03" } },
);

console.log(result.markdown);

const result = await client.academic.search({
  query: "quantum computing",
  providers: ["semantic-scholar", "arxiv", "pubmed"],
  limit: 20,
  yearFrom: 2021,
  yearTo: 2024,
});

result.results.forEach((publication) => {
  console.log(`Title: ${publication.title}`);
  console.log(`Authors: ${publication.authors?.map((a) => a.name).join(", ")}`);
  console.log(`Year: ${publication.year}`);
  console.log("---");
});

const result = await client.academic.fetch({
  ids: [
    "10.1038/nature12373", // DOI
    "12345678",            // PubMed ID
    "2301.00001",          // ArXiv ID
  ],
  fields: ["title", "authors", "year", "abstract", "doi"],
});

result.results.forEach((pub) => {
  console.log(`Title: ${pub.title}`);
  console.log(`Provider: ${pub.detectedProvider}`);
});

result.errors?.forEach((error) => {
  console.log(`Failed to fetch ${error.id}: ${error.error}`);
});

const result = await client.academic.parse({
  id: "1706.03762", // DOI, PubMed ID, ArXiv ID, Semantic Scholar ID, or provider URL
  model: "auto",    // "auto" | "nano" | "mini" | "pro" | "max"
});

console.log(`Title: ${result.title}`);
console.log(`Provider: ${result.detectedProvider}`);
console.log(`PDF: ${result.pdfURL}`);
console.log(result.markdown);
console.log(`Pages: ${result.pageCount}, Credits: ${result.credits}`);

const result = await client.academic.parse({
  url: "https://arxiv.org/abs/1706.03762",
  model: "nano",
});

console.log(result.markdown);

const result = await client.academic.findCitations({
  paragraph:
    "Transformers have revolutionized natural language processing. Attention mechanisms allow models to focus on relevant parts of the input.",
  providers: ["semantic-scholar", "arxiv", "pubmed"],
});

console.log(
  `Found ${result.totalCitations} citations across ${result.sentenceCount} sentences`,
);

for (const item of result.results) {
  console.log(`\nSentence: ${item.sentence}`);
  for (const citation of item.citations) {
    console.log(`  [Score: ${citation.score}/10] ${citation.title}`);
  }
}

const result = await client.academic.paperGraph({
  id: "10.1038/nature12373", // DOI, ArXiv ID, Semantic Scholar ID, OpenAlex ID, or URL
  citationsLimit: 20,
  referencesLimit: 20,
  citationsOffset: 0,
  referencesOffset: 0,
  fields: ["title", "authors", "year", "doi"],
});

console.log(`Paper: ${result.paper.title}`);
console.log(`Total Citations: ${result.totalCitations}`);
console.log(`Total References: ${result.totalReferences}`);

for (const citation of result.citations) {
  console.log(`  Cited by: ${citation.title} (${citation.year})`);
}

const result = await client.academic.similarPapers({
  id: "10.1038/nature12373",
  limit: 10,
  includeEdges: true, // include citation graph edges for visualization
  fields: ["title", "year", "doi"],
});

console.log(`Seed: ${result.seed.title}`);

for (const item of result.results) {
  console.log(`  [Similarity: ${item.similarity.toFixed(2)}] ${item.publication.title}`);
  if (item.citingIds) {
    console.log(`    Citing: ${item.citingIds.length} papers in result set`);
  }
}

const result = await client.academic.searchGrants({
  query: "machine learning healthcare",
  providers: ["grants-gov", "nih-reporter", "cordis", "ukri"],
  limit: 10,
  fundingMin: 100000,
  fundingMax: 1000000,
  deadlineFrom: "2026-01-01",
  deadlineTo: "2026-12-31",
});

console.log(`Found ${result.estimatedTotalResults} grants`);

for (const grant of result.results) {
  console.log(`Title: ${grant.title}`);
  console.log(`Agency: ${grant.agency} (${grant.region})`);
  console.log(`Funding: ${grant.currency} ${grant.fundingAmountMin}-${grant.fundingAmountMax}`);
  console.log(`Deadline: ${grant.deadlineDate ?? grant.closeDate ?? "N/A"}`);
  console.log(`URL: ${grant.url}`);
  console.log("---");
}

// Partial provider failures are reported in errors array
result.errors?.forEach((error) => {
  console.log(`Provider ${error.provider} failed: ${error.message}`);
});

const result = await client.document.parse(
  { url: "https://example.com/document.pdf" },
  { context: { documentId: "invoice-456" } },
);

console.log(result.documentId); // "invoice-456"

const [resultA, resultB] = await Promise.all([
  client.document.parse(
    { url: "https://example.com/doc-a.pdf" },
    { context: { documentId: "doc-a" } },
  ),
  client.document.parse(
    { url: "https://example.com/doc-b.pdf" },
    { context: { documentId: "doc-b" } },
  ),
]);

console.log(resultA.documentId); // "doc-a"
console.log(resultB.documentId); // "doc-b"

import {
  PDFVectorError,
  createClient,
  isPDFVectorUserError,
} from "@pdfvector/instance-client";

const client = createClient({ apiKey: "your-api-key" });

try {
  const result = await client.document.parse({
    url: "https://example.com/document.pdf",
  });
  console.log(result.markdown);
} catch (error) {
  if (isPDFVectorUserError(error)) {
    console.error(error.title);
    console.error(error.suggestion);
    return;
  }

  if (error instanceof PDFVectorError) {
    console.error(error.supportMessage);
    console.error(error.toAgentError());
    return;
  }

  // Network errors (DNS, connection refused, timeout) bubble up as TypeError.
  console.error("Unexpected Error:", error);
}

import { isPDFVectorUserError, isPDFVectorError } from "@pdfvector/instance-client";

try {
  await client.document.parse({ url: "https://example.com/page.html" });
} catch (error) {
  if (isPDFVectorUserError(error)) {
    console.error(error.suggestion);
  }

  if (isPDFVectorError(error) && error.retryableWithHigherModel) {
    console.error("Retry with a stronger model or a smaller document.");
  }
}

import {
  EmptyDocumentError,
  ExtractionFailedError,
  FileTooLargeError,
  InvalidSchemaError,
  NoPublicPDFError,
  PageLimitExceededError,
  PasswordProtectedError,
  TooManyRequestsError,
  UnauthorizedError,
  URLFetchError,
} from "@pdfvector/instance-client";

try {
  await client.document.parse({ url: "...", model: "nano" });
} catch (error) {
  if (error instanceof FileTooLargeError) {
    console.error(
      `File ${error.fileSizeMB}MB exceeds ${error.limitMB}MB limit for the '${error.model}' model`,
    );
  } else if (error instanceof PageLimitExceededError) {
    console.error(
      `Document has ${error.pageCount} pages; ${error.model} supports up to ${error.pageLimit}`,
    );
  } else if (error instanceof PasswordProtectedError) {
    console.error("Remove the password from the file and try again");
  } else if (error instanceof URLFetchError) {
    console.error(error.suggestion);
  } else if (error instanceof InvalidSchemaError) {
    console.error(error.reason);
  } else if (error instanceof NoPublicPDFError) {
    console.error("Provide a direct PDF URL or upload the paper file directly");
  } else if (error instanceof UnauthorizedError) {
    console.error("Invalid API key; check your dashboard");
  } else if (error instanceof TooManyRequestsError) {
    console.error(`Rate limit ${error.limit} exceeded; resets at ${error.resetAt}`);
  } else if (error instanceof EmptyDocumentError) {
    console.error("The document has no readable content");
  } else if (error instanceof ExtractionFailedError) {
    console.error(`Extraction failed. Hint: ${error.hint}`);
    if (error.rawText) console.error(`Model output sample: ${error.rawText}`);
  }
}

import {
  createClient,
  isPDFVectorError,
  isPDFVectorUserError,
  // Base error class — all errors inherit from this
  PDFVectorError,
  // HTTP-aligned error categories
  BadRequestError,
  UnauthorizedError,
  NotFoundError,
  ConflictError,
  TooManyRequestsError,
  UnprocessableContentError,
  InternalServerError,
  NotImplementedError,
  // Specialized error subclasses with typed metadata
  FileTooLargeError,
  PageLimitExceededError,
  PasswordProtectedError,
  UnsupportedFormatError,
  URLFetchError,
  InvalidDocumentURLError,
  InvalidBase64Error,
  TierNotSupportedError,
  InvalidSchemaError,
  NoInputProvidedError,
  EmptyDocumentError,
  NoTextDetectedError,
  ExtractionFailedError,
  AcademicPaperNotFoundError,
  NoPublicPDFError,
  // Underlying ORPC error — re-exported for advanced use cases
  ORPCError,
} from "@pdfvector/instance-client";

import type {
  Client,
  ClientContext,
  CreateClientOptions,
  ContractInputs,
  ContractOutputs,
  PDFVectorModel,
  PDFVectorAgentError,
  PDFVectorErrorCategory,
  PDFVectorErrorCode,
  PDFVectorErrorOrigin,
} from "@pdfvector/instance-client";