flexorch-sdk 0.1.0

package/dist/index.cjs

@@ -0,0 +1,722 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/models/dataset.ts
+var dataset_exports = {};
+__export(dataset_exports, {
+  Dataset: () => Dataset
+});
+var SUPPORTED_FORMATS, Dataset;
+var init_dataset = __esm({
+  "src/models/dataset.ts"() {
+    "use strict";
+    SUPPORTED_FORMATS = /* @__PURE__ */ new Set([
+      "json",
+      "jsonl",
+      "csv",
+      "parquet",
+      "md",
+      "xml",
+      "xlsx",
+      "rag"
+    ]);
+    Dataset = class _Dataset {
+      id;
+      name;
+      slug;
+      status;
+      rowCount;
+      createdAt;
+      availableFormats;
+      _transport;
+      constructor(data) {
+        this.id = data.id;
+        this.name = data.name;
+        this.slug = data.slug;
+        this.status = data.status;
+        this.rowCount = data.rowCount;
+        this.createdAt = data.createdAt;
+        this.availableFormats = data.availableFormats;
+        this._transport = data._transport;
+      }
+      static fromDict(data, transport) {
+        const fmt = data["format_summary"] ?? {};
+        const files = fmt["files"] ?? {};
+        return new _Dataset({
+          id: String(data["id"] ?? ""),
+          name: String(data["name"] ?? ""),
+          slug: String(data["slug"] ?? ""),
+          status: String(data["status"] ?? ""),
+          rowCount: Number(data["row_count"] ?? 0),
+          createdAt: String(data["created_at"] ?? ""),
+          availableFormats: Object.keys(files),
+          _transport: transport
+        });
+      }
+      async export(format) {
+        if (!SUPPORTED_FORMATS.has(format)) {
+          throw new Error(`Unsupported format "${format}". Choose from: ${[...SUPPORTED_FORMATS].sort().join(", ")}`);
+        }
+        return this._transport.getBytes(`/datasets/${this.id}/export`, { format });
+      }
+      async exportToS3(connectorId, format, prefix = "") {
+        if (!SUPPORTED_FORMATS.has(format)) {
+          throw new Error(`Unsupported format "${format}". Choose from: ${[...SUPPORTED_FORMATS].sort().join(", ")}`);
+        }
+        const data = await this._transport.post(`/datasets/${this.id}/export-s3`, {
+          format,
+          connector_id: connectorId,
+          prefix
+        });
+        return {
+          s3Key: String(data["s3_key"] ?? ""),
+          sizeBytes: Number(data["size_bytes"] ?? 0)
+        };
+      }
+      async index() {
+        const data = await this._transport.post(`/datasets/${this.id}/index`) ?? {};
+        return {
+          status: String(data["status"] ?? ""),
+          message: String(data["message"] ?? "")
+        };
+      }
+      async indexStatus() {
+        const data = await this._transport.get(`/datasets/${this.id}/index/status`) ?? {};
+        return {
+          status: String(data["status"] ?? "not_indexed"),
+          chunksIndexed: Number(data["chunks_indexed"] ?? 0),
+          totalChunks: Number(data["total_chunks"] ?? 0)
+        };
+      }
+      toString() {
+        return `Dataset(id=${this.id}, name=${this.name}, rows=${this.rowCount}, status=${this.status})`;
+      }
+    };
+  }
+});
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  AuthError: () => AuthError,
+  Connector: () => Connector,
+  Dataset: () => Dataset,
+  FlexOrchClient: () => FlexOrchClient,
+  FlexOrchError: () => FlexOrchError,
+  Job: () => Job,
+  JobFailedError: () => JobFailedError,
+  JobTimeoutError: () => JobTimeoutError,
+  NotFoundError: () => NotFoundError,
+  QuotaError: () => QuotaError,
+  RateLimitError: () => RateLimitError,
+  SearchResult: () => SearchResult,
+  ServerError: () => ServerError,
+  ValidationError: () => ValidationError,
+  version: () => version
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/errors.ts
+var FlexOrchError = class extends Error {
+  statusCode;
+  errorCode;
+  constructor(message, statusCode, errorCode) {
+    super(message);
+    this.name = "FlexOrchError";
+    this.statusCode = statusCode;
+    this.errorCode = errorCode;
+  }
+};
+var AuthError = class extends FlexOrchError {
+  constructor(message, statusCode = 401, errorCode) {
+    super(message, statusCode, errorCode);
+    this.name = "AuthError";
+  }
+};
+var QuotaError = class extends FlexOrchError {
+  remainingCredits;
+  resetAt;
+  constructor(message, statusCode = 402, errorCode, remainingCredits, resetAt) {
+    super(message, statusCode, errorCode);
+    this.name = "QuotaError";
+    this.remainingCredits = remainingCredits;
+    this.resetAt = resetAt;
+  }
+};
+var RateLimitError = class extends FlexOrchError {
+  retryAfter;
+  constructor(message, retryAfter = 60) {
+    super(message, 429, "RATE_LIMIT_EXCEEDED");
+    this.name = "RateLimitError";
+    this.retryAfter = retryAfter;
+  }
+};
+var NotFoundError = class extends FlexOrchError {
+  constructor(message, errorCode) {
+    super(message, 404, errorCode);
+    this.name = "NotFoundError";
+  }
+};
+var ValidationError = class extends FlexOrchError {
+  constructor(message, errorCode) {
+    super(message, 422, errorCode);
+    this.name = "ValidationError";
+  }
+};
+var ServerError = class extends FlexOrchError {
+  constructor(message, statusCode = 500, errorCode) {
+    super(message, statusCode, errorCode);
+    this.name = "ServerError";
+  }
+};
+var JobFailedError = class extends FlexOrchError {
+  jobId;
+  failureReason;
+  constructor(jobId, failureReason) {
+    super(`Job ${jobId} failed: ${failureReason}`);
+    this.name = "JobFailedError";
+    this.jobId = jobId;
+    this.failureReason = failureReason;
+  }
+};
+var JobTimeoutError = class extends FlexOrchError {
+  jobId;
+  timeout;
+  constructor(jobId, timeout) {
+    super(`Job ${jobId} did not complete within ${timeout}s`);
+    this.name = "JobTimeoutError";
+    this.jobId = jobId;
+    this.timeout = timeout;
+  }
+};
+
+// src/transport.ts
+var RETRY_STATUSES = /* @__PURE__ */ new Set([429, 500, 502, 503, 504]);
+async function parseError(res) {
+  const status = res.status;
+  let message = `HTTP ${status}`;
+  let code = "";
+  try {
+    const body = await res.json();
+    const err = body["error"] ?? {};
+    code = String(err["code"] ?? "");
+    message = String(err["message"] ?? body["detail"] ?? message);
+  } catch {
+    message = await res.text().catch(() => message) || message;
+  }
+  if (status === 401) return new AuthError(message, status, code);
+  if (status === 402) return new QuotaError(message, status, code);
+  if (status === 404) return new NotFoundError(message, code);
+  if (status === 422) return new ValidationError(message, code);
+  if (status === 429) {
+    const retryAfter = parseInt(res.headers.get("Retry-After") ?? "60") || 60;
+    return new RateLimitError(message, retryAfter);
+  }
+  if (status >= 500) return new ServerError(message, status, code);
+  return new FlexOrchError(message, status, code);
+}
+function sleep(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+var Transport = class {
+  baseUrl;
+  defaultHeaders;
+  timeout;
+  maxRetries;
+  fetchFn;
+  constructor(apiKey, baseUrl, timeout, maxRetries, fetchFn) {
+    this.baseUrl = baseUrl.replace(/\/$/, "");
+    this.timeout = timeout;
+    this.maxRetries = maxRetries;
+    this.fetchFn = fetchFn ?? globalThis.fetch.bind(globalThis);
+    this.defaultHeaders = {
+      "X-API-KEY": apiKey,
+      "User-Agent": "flexorch-sdk-js/0.1.0"
+    };
+  }
+  url(path, params) {
+    const base = `${this.baseUrl}/${path.replace(/^\//, "")}`;
+    if (!params) return base;
+    return `${base}?${new URLSearchParams(params)}`;
+  }
+  async doRequest(method, path, options = {}) {
+    const url = this.url(path, options.params);
+    const headers = { ...this.defaultHeaders };
+    let body;
+    if (options.json !== void 0) {
+      headers["Content-Type"] = "application/json";
+      body = JSON.stringify(options.json);
+    } else if (options.form) {
+      body = options.form;
+    }
+    let lastError;
+    for (let attempt = 0; attempt < this.maxRetries; attempt++) {
+      const controller = new AbortController();
+      const timer = setTimeout(() => controller.abort(), this.timeout * 1e3);
+      try {
+        const res = await this.fetchFn(url, {
+          method,
+          headers,
+          body,
+          signal: controller.signal
+        });
+        clearTimeout(timer);
+        if (RETRY_STATUSES.has(res.status) && attempt < this.maxRetries - 1) {
+          const wait = parseInt(res.headers.get("Retry-After") ?? "") || 2 ** attempt;
+          await sleep(wait * 1e3);
+          continue;
+        }
+        if (!res.ok) throw await parseError(res);
+        if (res.status === 204) return null;
+        const ct = res.headers.get("content-type") ?? "";
+        if (!ct.includes("application/json")) return null;
+        const text = await res.text();
+        if (!text.trim()) return null;
+        return JSON.parse(text);
+      } catch (err) {
+        clearTimeout(timer);
+        if (err instanceof FlexOrchError) throw err;
+        lastError = err;
+        if (attempt < this.maxRetries - 1) await sleep(2 ** attempt * 1e3);
+      }
+    }
+    throw new FlexOrchError(
+      `Request failed after ${this.maxRetries} attempts: ${lastError?.message}`
+    );
+  }
+  async getBytes(path, params) {
+    const url = this.url(path, params);
+    const res = await this.fetchFn(url, { headers: this.defaultHeaders });
+    if (!res.ok) throw await parseError(res);
+    return new Uint8Array(await res.arrayBuffer());
+  }
+  get(path, params) {
+    return params ? this.doRequest("GET", path, { params }) : this.doRequest("GET", path);
+  }
+  post(path, json) {
+    return this.doRequest("POST", path, { json });
+  }
+  postForm(path, form) {
+    return this.doRequest("POST", path, { form });
+  }
+  delete(path) {
+    return this.doRequest("DELETE", path);
+  }
+};
+
+// src/models/job.ts
+var Job = class _Job {
+  id;
+  status;
+  qualityGrade;
+  qualityScore;
+  documentId;
+  hasDataset;
+  failureReason;
+  _transport;
+  constructor(data) {
+    this.id = data.id;
+    this.status = data.status;
+    this.qualityGrade = data.qualityGrade;
+    this.qualityScore = data.qualityScore;
+    this.documentId = data.documentId;
+    this.hasDataset = data.hasDataset;
+    this.failureReason = data.failureReason;
+    this._transport = data._transport;
+  }
+  static fromDict(data, transport) {
+    const quality = data["quality"] ?? {};
+    return new _Job({
+      id: String(data["job_id"] ?? data["id"] ?? ""),
+      status: String(data["status"] ?? ""),
+      qualityGrade: quality["grade"] ?? null,
+      qualityScore: quality["score"] ?? null,
+      documentId: data["document_id"] ?? null,
+      hasDataset: Boolean(data["has_dataset"] ?? false),
+      failureReason: data["failure_reason"] ?? null,
+      _transport: transport
+    });
+  }
+  async wait(opts = {}) {
+    const timeout = opts.timeout ?? 300;
+    const pollInterval = opts.pollInterval ?? 2;
+    const deadline = Date.now() + timeout * 1e3;
+    if (this.status === "completed" || this.status === "failed") {
+      if (this.status === "failed") {
+        throw new JobFailedError(this.id, this.failureReason ?? "unknown");
+      }
+      return this;
+    }
+    while (Date.now() < deadline) {
+      await sleep2(pollInterval * 1e3);
+      const data = await this._transport.get(`/jobs/${this.id}`);
+      const updated = _Job.fromDict(data, this._transport);
+      if (updated.status === "completed") return updated;
+      if (updated.status === "failed") {
+        throw new JobFailedError(updated.id, updated.failureReason ?? "unknown");
+      }
+    }
+    throw new JobTimeoutError(this.id, timeout);
+  }
+  async dataset() {
+    if (!this.hasDataset) return null;
+    const data = await this._transport.get("/datasets", {
+      job_id: this.id
+    });
+    const items = data["items"] ?? [];
+    if (items.length === 0) return null;
+    const { Dataset: Dataset2 } = await Promise.resolve().then(() => (init_dataset(), dataset_exports));
+    return Dataset2.fromDict(items[0], this._transport);
+  }
+  toString() {
+    return `Job(id=${this.id}, status=${this.status}, grade=${this.qualityGrade})`;
+  }
+};
+function sleep2(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+
+// src/models/search.ts
+var SearchResult = class _SearchResult {
+  chunkId;
+  text;
+  score;
+  datasetId;
+  chunkIndex;
+  tokenCount;
+  metadata;
+  constructor(data) {
+    this.chunkId = data.chunkId;
+    this.text = data.text;
+    this.score = data.score;
+    this.datasetId = data.datasetId;
+    this.chunkIndex = data.chunkIndex;
+    this.tokenCount = data.tokenCount;
+    this.metadata = data.metadata;
+  }
+  static fromDict(data) {
+    return new _SearchResult({
+      chunkId: String(data["chunk_id"] ?? ""),
+      text: String(data["text"] ?? ""),
+      score: Number(data["score"] ?? 0),
+      datasetId: String(data["dataset_id"] ?? ""),
+      chunkIndex: Number(data["chunk_index"] ?? 0),
+      tokenCount: Number(data["token_count"] ?? 0),
+      metadata: data["metadata"] ?? {}
+    });
+  }
+  toString() {
+    return `SearchResult(score=${this.score.toFixed(3)}, datasetId=${this.datasetId}, chunkIndex=${this.chunkIndex})`;
+  }
+};
+
+// src/resources/jobs.ts
+var JobsResource = class {
+  constructor(_t) {
+    this._t = _t;
+  }
+  _t;
+  async get(jobId) {
+    const data = await this._t.get(`/jobs/${jobId}`);
+    return Job.fromDict(data, this._t);
+  }
+  async list(opts = {}) {
+    const params = {};
+    if (opts.page !== void 0) params["page"] = String(opts.page);
+    if (opts.pageSize !== void 0) params["page_size"] = String(opts.pageSize);
+    const data = await this._t.get("/jobs", params);
+    const items = data["items"] ?? [];
+    return items.map((item) => Job.fromDict(item, this._t));
+  }
+};
+
+// src/resources/datasets.ts
+init_dataset();
+var DatasetsResource = class {
+  constructor(_t) {
+    this._t = _t;
+  }
+  _t;
+  async get(datasetId) {
+    const data = await this._t.get(`/datasets/${datasetId}`);
+    return Dataset.fromDict(data, this._t);
+  }
+  async list(opts = {}) {
+    const params = {};
+    if (opts.page !== void 0) params["page"] = String(opts.page);
+    if (opts.pageSize !== void 0) params["page_size"] = String(opts.pageSize);
+    const data = await this._t.get("/datasets", params);
+    const items = data["items"] ?? [];
+    return items.map((item) => Dataset.fromDict(item, this._t));
+  }
+};
+
+// src/resources/usage.ts
+var UsageResource = class {
+  constructor(_t) {
+    this._t = _t;
+  }
+  _t;
+  async current() {
+    const data = await this._t.get("/usage/current");
+    return {
+      plan: String(data["plan"] ?? ""),
+      creditsUsed: Number(data["credits_used"] ?? 0),
+      creditsLimit: Number(data["credits_limit"] ?? 0),
+      creditsRemaining: Number(data["credits_remaining"] ?? 0),
+      resetAt: String(data["reset_at"] ?? ""),
+      periodStart: String(data["period_start"] ?? ""),
+      periodEnd: String(data["period_end"] ?? "")
+    };
+  }
+};
+
+// src/resources/webhooks.ts
+var VALID_EVENTS = /* @__PURE__ */ new Set(["dataset.ready", "job.completed", "job.failed"]);
+function webhookFromDict(data) {
+  return {
+    id: String(data["id"] ?? ""),
+    url: String(data["url"] ?? ""),
+    events: data["events"] ?? [],
+    active: Boolean(data["active"] ?? true),
+    createdAt: String(data["created_at"] ?? "")
+  };
+}
+var WebhooksResource = class {
+  constructor(_t) {
+    this._t = _t;
+  }
+  _t;
+  async register(url, events) {
+    const invalid = events.filter((e) => !VALID_EVENTS.has(e));
+    if (invalid.length > 0) {
+      throw new Error(`Unknown event types: ${invalid.join(", ")}. Valid: ${[...VALID_EVENTS].join(", ")}`);
+    }
+    const data = await this._t.post("/webhooks", { url, events });
+    return webhookFromDict(data);
+  }
+  async list() {
+    const data = await this._t.get("/webhooks");
+    const items = data["items"] ?? [];
+    return items.map(webhookFromDict);
+  }
+  async delete(webhookId) {
+    await this._t.delete(`/webhooks/${webhookId}`);
+  }
+};
+
+// src/models/connector.ts
+var Connector = class _Connector {
+  id;
+  name;
+  type;
+  active;
+  lastTestedAt;
+  lastUsedAt;
+  createdAt;
+  constructor(data) {
+    this.id = data.id;
+    this.name = data.name;
+    this.type = data.type;
+    this.active = data.active;
+    this.lastTestedAt = data.lastTestedAt;
+    this.lastUsedAt = data.lastUsedAt;
+    this.createdAt = data.createdAt;
+  }
+  static fromDict(data) {
+    return new _Connector({
+      id: String(data["id"] ?? ""),
+      name: String(data["name"] ?? ""),
+      type: String(data["type"] ?? ""),
+      active: Boolean(data["active"] ?? true),
+      lastTestedAt: data["last_tested_at"] ?? null,
+      lastUsedAt: data["last_used_at"] ?? null,
+      createdAt: String(data["created_at"] ?? "")
+    });
+  }
+  toString() {
+    return `Connector(id=${this.id}, name=${this.name}, type=${this.type})`;
+  }
+};
+
+// src/resources/connectors.ts
+var VALID_TYPES = /* @__PURE__ */ new Set(["s3", "gcs", "azure_blob"]);
+var ConnectorsResource = class {
+  constructor(_t) {
+    this._t = _t;
+  }
+  _t;
+  async create(name, type, config) {
+    if (!VALID_TYPES.has(type)) {
+      throw new Error(`Unknown connector type "${type}". Valid: ${[...VALID_TYPES].join(", ")}`);
+    }
+    const data = await this._t.post("/connectors", { name, type, config });
+    return Connector.fromDict(data);
+  }
+  async list() {
+    const data = await this._t.get("/connectors");
+    const items = data["items"] ?? [];
+    return items.map(Connector.fromDict);
+  }
+  async get(connectorId) {
+    const data = await this._t.get(`/connectors/${connectorId}`);
+    return Connector.fromDict(data);
+  }
+  async delete(connectorId) {
+    await this._t.delete(`/connectors/${connectorId}`);
+  }
+  async test(connectorId) {
+    const data = await this._t.post(`/connectors/${connectorId}/test`) ?? {};
+    return {
+      success: Boolean(data["success"] ?? false),
+      latencyMs: data["latency_ms"] !== void 0 ? Number(data["latency_ms"]) : null,
+      message: String(data["message"] ?? "")
+    };
+  }
+};
+
+// src/client.ts
+var DEFAULT_BASE_URL = "https://api.flexorch.com/v1";
+var FlexOrchClient = class {
+  jobs;
+  datasets;
+  usage;
+  webhooks;
+  connectors;
+  _transport;
+  constructor(apiKeyOrOptions = {}) {
+    const opts = typeof apiKeyOrOptions === "string" ? { apiKey: apiKeyOrOptions } : apiKeyOrOptions;
+    const apiKey = opts.apiKey ?? process.env["FLEXORCH_API_KEY"] ?? "";
+    if (!apiKey) {
+      throw new Error(
+        "No API key provided. Pass apiKey or set the FLEXORCH_API_KEY environment variable."
+      );
+    }
+    this._transport = new Transport(
+      apiKey,
+      opts.baseUrl ?? DEFAULT_BASE_URL,
+      opts.timeout ?? 30,
+      opts.maxRetries ?? 3,
+      opts._fetch
+    );
+    this.jobs = new JobsResource(this._transport);
+    this.datasets = new DatasetsResource(this._transport);
+    this.usage = new UsageResource(this._transport);
+    this.webhooks = new WebhooksResource(this._transport);
+    this.connectors = new ConnectorsResource(this._transport);
+  }
+  async process(filePath, opts = {}) {
+    const { createReadStream, statSync } = await import("fs");
+    const { basename } = await import("path");
+    if (!statSync(filePath, { throwIfNoEntry: false })) {
+      throw new Error(`File not found: ${filePath}`);
+    }
+    const form = new FormData();
+    const stream = createReadStream(filePath);
+    const chunks = [];
+    for await (const chunk of stream) {
+      chunks.push(chunk);
+    }
+    const blob = new Blob([Buffer.concat(chunks)], { type: "application/octet-stream" });
+    form.append("file", blob, basename(filePath));
+    form.append("locale", opts.locale ?? "und");
+    if (opts.pipelineConfig) {
+      form.append("pipeline_config", JSON.stringify(opts.pipelineConfig));
+    }
+    const data = await this._transport.postForm("/data-process/async", form);
+    return Job.fromDict(data, this._transport);
+  }
+  async processMany(filePaths, opts = {}) {
+    const jobs = [];
+    for (const fp of filePaths) {
+      jobs.push(await this.process(fp, opts));
+    }
+    return jobs;
+  }
+  async processFromS3(connectorId, keys, opts = {}) {
+    const jobs = [];
+    for (const key of keys) {
+      const form = new FormData();
+      form.append("locale", opts.locale ?? "und");
+      form.append("source", JSON.stringify({ connector_id: connectorId, keys: [key] }));
+      if (opts.pipelineConfig) {
+        form.append("pipeline_config", JSON.stringify(opts.pipelineConfig));
+      }
+      const data = await this._transport.postForm("/data-process/async", form);
+      jobs.push(Job.fromDict(data, this._transport));
+    }
+    return jobs;
+  }
+  async search(query, opts = {}) {
+    const body = {
+      query,
+      top_k: opts.topK ?? 10
+    };
+    if (opts.filters) {
+      const f = opts.filters;
+      const mapped = {};
+      if (f.documentType !== void 0) mapped["document_type"] = f.documentType;
+      if (f.language !== void 0) mapped["language"] = f.language;
+      if (f.piiMasked !== void 0) mapped["pii_masked"] = f.piiMasked;
+      if (f.qualityGrade !== void 0) mapped["quality_grade"] = f.qualityGrade;
+      body["filters"] = mapped;
+    }
+    const data = await this._transport.post("/search", body) ?? {};
+    const results = data["results"] ?? [];
+    return results.map(SearchResult.fromDict);
+  }
+  toString() {
+    return `FlexOrchClient(baseUrl=${DEFAULT_BASE_URL})`;
+  }
+};
+
+// src/index.ts
+init_dataset();
+var version = "0.1.0";
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AuthError,
+  Connector,
+  Dataset,
+  FlexOrchClient,
+  FlexOrchError,
+  Job,
+  JobFailedError,
+  JobTimeoutError,
+  NotFoundError,
+  QuotaError,
+  RateLimitError,
+  SearchResult,
+  ServerError,
+  ValidationError,
+  version
+});