@frontal-labs/ontology 0.0.1 → 1.0.1

package/dist/index.mjs

@@ -1,421 +1,2083 @@
-var __defProp = Object.defineProperty;
-var __defProps = Object.defineProperties;
-var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
-var __getOwnPropSymbols = Object.getOwnPropertySymbols;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __propIsEnum = Object.prototype.propertyIsEnumerable;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues = (a, b) => {
-  for (var prop in b || (b = {}))
-    if (__hasOwnProp.call(b, prop))
-      __defNormalProp(a, prop, b[prop]);
-  if (__getOwnPropSymbols)
-    for (var prop of __getOwnPropSymbols(b)) {
-      if (__propIsEnum.call(b, prop))
-        __defNormalProp(a, prop, b[prop]);
-    }
-  return a;
-};
-var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
-var __async = (__this, __arguments, generator) => {
-  return new Promise((resolve, reject) => {
-    var fulfilled = (value) => {
-      try {
-        step(generator.next(value));
-      } catch (e) {
-        reject(e);
-      }
-    };
-    var rejected = (value) => {
-      try {
-        step(generator.throw(value));
-      } catch (e) {
-        reject(e);
-      }
-    };
-    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
-    step((generator = generator.apply(__this, __arguments)).next());
-  });
-};
+// ../core/dist/index.js
+import { z } from "zod";
 
-// src/index.ts
-import { FrontalClient, getDefaultClient, HttpClient } from "@frontal-labs/core";
+// ../../node_modules/.bun/@t3-oss+env-core@0.13.11+dcb9db7a51b27bde/node_modules/@t3-oss/env-core/dist/standard.js
+function ensureSynchronous(value, message) {
+  if (value instanceof Promise) throw new Error(message);
+}
+function parseWithDictionary(dictionary, value) {
+  const result = {};
+  const issues = [];
+  for (const key in dictionary) {
+    const propResult = dictionary[key]["~standard"].validate(value[key]);
+    ensureSynchronous(propResult, `Validation must be synchronous, but ${key} returned a Promise.`);
+    if (propResult.issues) {
+      issues.push(...propResult.issues.map((issue) => ({
+        ...issue,
+        message: issue.message,
+        path: [key, ...issue.path ?? []]
+      })));
+      continue;
+    }
+    result[key] = propResult.value;
+  }
+  if (issues.length) return { issues };
+  return { value: result };
+}
 
-// src/service.ts
-import {
-  createPageResult
-} from "@frontal-labs/core";
+// ../../node_modules/.bun/@t3-oss+env-core@0.13.11+dcb9db7a51b27bde/node_modules/@t3-oss/env-core/dist/index.js
+function createEnv(opts) {
+  const runtimeEnv = opts.runtimeEnvStrict ?? opts.runtimeEnv ?? process.env;
+  if (opts.emptyStringAsUndefined ?? false) {
+    for (const [key, value] of Object.entries(runtimeEnv)) if (value === "") delete runtimeEnv[key];
+  }
+  if (!!opts.skipValidation) {
+    if (opts.extends) for (const preset of opts.extends) preset.skipValidation = true;
+    return runtimeEnv;
+  }
+  const _client = typeof opts.client === "object" ? opts.client : {};
+  const _server = typeof opts.server === "object" ? opts.server : {};
+  const _shared = typeof opts.shared === "object" ? opts.shared : {};
+  const isServer = opts.isServer ?? (typeof window === "undefined" || "Deno" in window);
+  const finalSchemaShape = isServer ? {
+    ..._server,
+    ..._shared,
+    ..._client
+  } : {
+    ..._client,
+    ..._shared
+  };
+  const parsed = opts.createFinalSchema?.(finalSchemaShape, isServer)?.["~standard"].validate(runtimeEnv) ?? parseWithDictionary(finalSchemaShape, runtimeEnv);
+  ensureSynchronous(parsed, "Validation must be synchronous");
+  const onValidationError = opts.onValidationError ?? ((issues) => {
+    console.error("\u274C Invalid environment variables:", issues);
+    throw new Error("Invalid environment variables");
+  });
+  const onInvalidAccess = opts.onInvalidAccess ?? (() => {
+    throw new Error("\u274C Attempted to access a server-side environment variable on the client");
+  });
+  if (parsed.issues) return onValidationError(parsed.issues);
+  const isServerAccess = (prop) => {
+    if (!opts.clientPrefix) return true;
+    return !prop.startsWith(opts.clientPrefix) && !(prop in _shared);
+  };
+  const isValidServerAccess = (prop) => {
+    return isServer || !isServerAccess(prop);
+  };
+  const ignoreProp = (prop) => {
+    return prop === "__esModule" || prop === "$$typeof";
+  };
+  const extendedObj = (opts.extends ?? []).reduce((acc, curr) => {
+    return Object.assign(acc, curr);
+  }, {});
+  const fullObj = Object.assign(extendedObj, parsed.value);
+  return new Proxy(fullObj, { get(target, prop) {
+    if (typeof prop !== "string") return void 0;
+    if (ignoreProp(prop)) return void 0;
+    if (!isValidServerAccess(prop)) return onInvalidAccess(prop);
+    return Reflect.get(target, prop);
+  } });
+}
 
-// src/schemas.ts
-import { timestampSchema } from "@frontal-labs/core";
-import { z } from "zod";
-var FieldTypeSchema = z.enum([
-  "string",
-  "integer",
-  "float",
-  "boolean",
-  "uuid",
-  "timestamp",
-  "currency",
-  "json",
-  "array",
-  "enum",
-  "vector",
-  "text"
-]);
-var RelationshipTypeSchema = z.enum([
-  "hasOne",
-  "hasMany",
-  "belongsTo",
-  "manyToMany"
-]);
-var FieldDefinitionSchema = z.object({
-  type: FieldTypeSchema,
-  required: z.boolean().default(false),
-  primary: z.boolean().default(false),
-  unique: z.boolean().default(false),
-  default: z.unknown().optional(),
-  substrate: z.string().optional(),
-  computed: z.boolean().optional(),
-  derivedBy: z.string().optional(),
-  cache: z.object({
-    ttl: z.string()
-  }).optional(),
-  auto: z.boolean().optional(),
-  enum: z.array(z.string()).optional(),
-  dimensions: z.number().int().optional(),
-  items: z.string().optional(),
-  description: z.string().optional()
-}).passthrough();
-var RelationshipDefinitionSchema = z.object({
-  name: z.string().optional(),
-  type: RelationshipTypeSchema,
-  targetEntity: z.string(),
-  foreignKey: z.string().optional(),
-  substrate: z.string().optional(),
-  cascade: z.object({
-    delete: z.enum(["hard", "soft", "restrict", "nullify"]),
-    update: z.enum(["cascade", "restrict"])
-  }).optional(),
-  computed: z.record(z.string(), z.unknown()).optional(),
-  description: z.string().optional()
-}).passthrough();
-var SubstrateRoutingSchema = z.object({
-  operational: z.string().optional(),
-  analytical: z.string().optional(),
-  semantic: z.string().optional(),
-  cache: z.string().optional()
-}).passthrough();
-var SemanticMetadataSchema = z.object({
-  description: z.string().optional(),
-  lifecycle: z.array(z.string()).optional(),
-  criticalFields: z.array(z.string()).optional(),
-  significantEvents: z.array(z.string()).optional(),
-  tags: z.array(z.string()).optional()
-}).passthrough();
-var IndexDefinitionSchema = z.object({
-  name: z.string().optional(),
-  fields: z.array(z.string()).min(1),
+// ../core/dist/index.js
+import { z as z2 } from "zod";
+import { z as z3 } from "zod";
+import { z as z4 } from "zod";
+var DEFAULT_BASE_URL = "https://api.frontal.dev/v1";
+var API_KEY_PREFIX = "frt_";
+var BACKOFF_STRATEGIES = [
+  "exponential",
+  "linear",
+  "constant"
+];
+var DEFAULT_RETRY_ON = [429, 500, 502, 503, 504];
+var EXPONENTIAL_BASE = 2;
+var JITTER_MAX = 200;
+var SDK_VERSION = "1.0.1";
+var timestampSchema = z.date().transform((date) => new Date(date));
+var responseMetaSchema = z.object({
+  requestId: z.string().min(1),
+  timestamp: timestampSchema,
+  version: z.string().optional(),
   substrate: z.string().optional(),
-  unique: z.boolean().default(false),
-  type: z.enum(["btree", "hash", "gin", "gist", "brin"]).default("btree")
-}).passthrough();
-var ModelDefinitionSchema = z.object({
-  name: z.string(),
-  displayName: z.string().optional(),
-  description: z.string().optional(),
-  extends: z.string().optional(),
-  mixins: z.array(z.string()).optional(),
-  fields: z.record(z.string(), FieldDefinitionSchema),
-  relationships: z.record(z.string(), RelationshipDefinitionSchema).optional(),
-  substrates: SubstrateRoutingSchema.optional(),
-  semantics: SemanticMetadataSchema.optional(),
-  indexes: z.array(IndexDefinitionSchema).optional(),
-  status: z.enum(["draft", "active", "deprecated"]).default("draft")
+  latency: z.object({
+    total: z.number().int().min(0),
+    substrate: z.number().int().min(0).optional()
+  }).optional()
 }).strict();
-var ModelSchema = ModelDefinitionSchema.extend({
-  id: z.string(),
-  version: z.number().int(),
-  createdAt: timestampSchema,
-  updatedAt: timestampSchema,
-  entityCount: z.number().int().optional()
-}).passthrough();
-var MigrationPlanSchema = z.object({
-  id: z.string(),
-  modelId: z.string(),
-  fromVersion: z.number().int(),
-  toVersion: z.number().int(),
-  changes: z.array(
-    z.object({
-      type: z.enum([
-        "add-field",
-        "remove-field",
-        "modify-field",
-        "add-relationship",
-        "remove-relationship"
-      ]),
-      description: z.string(),
-      impact: z.enum(["breaking", "non-breaking", "data-loss"]),
-      sql: z.string().optional()
-    })
-  ),
-  riskLevel: z.enum(["low", "medium", "high", "critical"]),
-  estimatedDowntime: z.string().optional(),
-  rolloutStrategy: z.enum([
-    "zero-downtime",
-    "maintenance-window",
-    "immediate"
-  ]),
-  createdAt: timestampSchema
-}).passthrough();
-var RuleDefinitionSchema = z.object({
-  name: z.string(),
-  description: z.string().optional(),
-  entityTypes: z.array(z.string()).min(1),
-  condition: z.string(),
-  action: z.enum(["validate", "transform", "notify"]),
-  severity: z.enum(["error", "warning", "info"]),
-  enabled: z.boolean().default(true)
+var paginationMetaSchema = z.object({
+  cursor: z.string().min(1),
+  hasMore: z.boolean(),
+  limit: z.number().int().positive().optional(),
+  total: z.number().int().min(0).optional(),
+  offset: z.number().int().min(0).optional()
 }).strict();
-var MixinDefinitionSchema = z.object({
-  name: z.string(),
-  description: z.string().optional(),
-  fields: z.record(z.string(), FieldDefinitionSchema),
-  relationships: z.record(z.string(), RelationshipDefinitionSchema).optional(),
-  appliesTo: z.array(z.string()).optional()
+var errorFieldSchema = z.object({
+  field: z.string().describe("Field name"),
+  code: z.string().describe("Error code"),
+  message: z.string().describe("Error message")
 }).strict();
-
-// src/service.ts
-var asPagePayload = (raw) => raw;
-var OntologyService = class {
-  constructor(http) {
-    this.http = http;
-    this.migrations = new MigrationsNamespace(this.http);
-    this.rules = new RulesNamespace(this.http);
-    this.mixins = new MixinsNamespace(this.http);
-    this.generation = new GenerationNamespace(this.http);
-  }
-  use(name) {
-    return new ModelAccessor(name, this.http);
-  }
-  list() {
-    return __async(this, arguments, function* (opts = {}) {
-      const raw = yield this.http.get("/ontology/engine/runs", opts);
-      return createPageResult(
-        asPagePayload(raw),
-        (cursor) => this.list(__spreadProps(__spreadValues({}, opts), { cursor }))
+var docsUrlSchema = z.string().url().refine((url) => /^https?:\/\//.test(url), {
+  message: "docs must be an http or https URL"
+});
+var errorResponseSchema = z.object({
+  code: z.string().min(1).describe("Error code"),
+  message: z.string().min(1).describe("Error message"),
+  requestId: z.string().min(1).describe("Request ID"),
+  docs: docsUrlSchema.optional().describe("Documentation URL"),
+  fields: z.array(errorFieldSchema).optional().describe("Array of error fields")
+}).strict();
+var retryStatusCodeSchema = z.number().int().refine((status) => status === 429 || status >= 500 && status <= 599, {
+  message: "Retry status codes must be 429 or 5xx"
+});
+var retryConfigSchema = z.object({
+  maxAttempts: z.number().int().positive().default(3),
+  baseDelay: z.number().int().positive().default(1e3),
+  strategy: z.enum(BACKOFF_STRATEGIES).default("exponential"),
+  on: z.array(retryStatusCodeSchema).default(DEFAULT_RETRY_ON),
+  jitter: z.boolean().default(true)
+}).strict().default({
+  maxAttempts: 3,
+  baseDelay: 1e3,
+  strategy: "exponential",
+  on: DEFAULT_RETRY_ON,
+  jitter: true
+});
+var numericValueSchema = z.union([
+  z.number(),
+  z.literal(Number.POSITIVE_INFINITY),
+  z.literal(Number.NEGATIVE_INFINITY)
+]);
+var arrayFilterValueSchema = z.union([
+  z.array(z.string()),
+  z.array(numericValueSchema)
+]);
+var scalarFilterValueSchema = z.union([
+  z.string(),
+  numericValueSchema,
+  z.boolean(),
+  z.date(),
+  z.null(),
+  arrayFilterValueSchema
+]);
+var comparableValueSchema = z.union([numericValueSchema, z.date()]);
+var filterOperatorSchema = z.object({
+  eq: scalarFilterValueSchema.optional(),
+  ne: scalarFilterValueSchema.optional(),
+  gt: comparableValueSchema.optional(),
+  gte: comparableValueSchema.optional(),
+  lt: comparableValueSchema.optional(),
+  lte: comparableValueSchema.optional(),
+  in: arrayFilterValueSchema.optional(),
+  nin: arrayFilterValueSchema.optional(),
+  contains: z.string().optional(),
+  startsWith: z.string().optional(),
+  endsWith: z.string().optional()
+}).strict().refine(
+  (value) => Object.values(value).some((entry) => entry !== void 0),
+  {
+    message: "At least one filter operator is required"
+  }
+);
+var filterValueSchema = z.union([
+  scalarFilterValueSchema,
+  filterOperatorSchema
+]);
+var filterConditionsSchema = z.record(z.string(), filterValueSchema);
+var pageResultSchema = z.object({
+  data: z.array(z.unknown()),
+  meta: responseMetaSchema.optional(),
+  pagination: paginationMetaSchema
+}).strict();
+var FrontalError = class extends Error {
+  code;
+  requestId;
+  statusCode;
+  docs;
+  rateLimit;
+  /**
+   * @param response - The parsed error response from the API.
+   * @param statusCode - The HTTP status code.
+   * @param rateLimit - Optional rate-limit headers from the response.
+   */
+  constructor(response, statusCode, rateLimit) {
+    super(response.message);
+    this.name = "FrontalError";
+    this.code = response.code;
+    this.requestId = response.requestId;
+    this.statusCode = statusCode;
+    this.docs = response.docs;
+    this.rateLimit = rateLimit;
+    Object.setPrototypeOf(this, new.target.prototype);
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this);
+    }
+  }
+};
+var NotFoundError = class extends FrontalError {
+  constructor(r, rateLimit) {
+    super(r, 404, rateLimit);
+    this.name = "NotFoundError";
+  }
+};
+var UnauthorizedError = class extends FrontalError {
+  constructor(r, rateLimit) {
+    super(r, 401, rateLimit);
+    this.name = "UnauthorizedError";
+  }
+};
+var ForbiddenError = class extends FrontalError {
+  constructor(r, rateLimit) {
+    super(r, 403, rateLimit);
+    this.name = "ForbiddenError";
+  }
+};
+var ValidationError = class extends FrontalError {
+  /** Per-field validation errors returned by the API. */
+  fields;
+  constructor(r, rateLimit) {
+    super(r, 400, rateLimit);
+    this.name = "ValidationError";
+    this.fields = r.fields ?? [];
+  }
+};
+var ConflictError = class extends FrontalError {
+  constructor(r, rateLimit) {
+    super(r, 409, rateLimit);
+    this.name = "ConflictError";
+  }
+};
+var RateLimitError = class extends FrontalError {
+  /** Recommended delay in seconds before retrying. */
+  retryAfter;
+  constructor(r, retryAfter, rateLimit) {
+    super(r, 429, rateLimit);
+    this.name = "RateLimitError";
+    this.retryAfter = retryAfter;
+  }
+};
+var ServiceError = class extends FrontalError {
+  constructor(r, status, rateLimit) {
+    super(r, status, rateLimit);
+    this.name = "ServiceError";
+  }
+};
+var NetworkError = class extends Error {
+  constructor(cause) {
+    super("Network error \u2014 could not reach Frontal API");
+    this.cause = cause;
+    this.name = "NetworkError";
+    Object.setPrototypeOf(this, new.target.prototype);
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, new.target);
+    }
+  }
+};
+function normalizeErrorBody(body) {
+  const parsed = errorResponseSchema.safeParse(body);
+  if (parsed.success) return parsed.data;
+  const fallback = typeof body === "object" && body !== null ? body : {};
+  const code = typeof fallback.code === "string" && fallback.code.length > 0 ? fallback.code : "UNKNOWN_ERROR";
+  const hasExplicitCode = typeof fallback.code === "string" && fallback.code.length > 0;
+  const message = hasExplicitCode && typeof fallback.message === "string" && fallback.message.length > 0 ? fallback.message : "An unknown error occurred";
+  return {
+    code,
+    message,
+    requestId: typeof fallback.requestId === "string" && fallback.requestId.length > 0 ? fallback.requestId : "unknown",
+    docs: typeof fallback.docs === "string" ? fallback.docs : void 0,
+    fields: Array.isArray(fallback.fields) ? fallback.fields : void 0
+  };
+}
+function parseFrontalError(body, status, retryAfter, rateLimit) {
+  const normalized = normalizeErrorBody(body);
+  switch (status) {
+    case 400:
+      return new ValidationError(normalized, rateLimit);
+    case 401:
+      return new UnauthorizedError(normalized, rateLimit);
+    case 403:
+      return new ForbiddenError(normalized, rateLimit);
+    case 404:
+      return new NotFoundError(normalized, rateLimit);
+    case 409:
+      return new ConflictError(normalized, rateLimit);
+    case 429: {
+      const parsedRetry = retryAfter ? Number.parseInt(retryAfter, 10) : Number.NaN;
+      return new RateLimitError(
+        normalized,
+        Number.isFinite(parsedRetry) ? parsedRetry : 60,
+        rateLimit
       );
-    });
+    }
+    default:
+      return new ServiceError(normalized, status, rateLimit);
   }
-  create(definition) {
-    return __async(this, null, function* () {
-      const body = ModelDefinitionSchema.parse(definition);
-      return this.http.post("/ontology/engine/runs", body);
-    });
+}
+var CircuitBreaker = class {
+  failures = 0;
+  lastFailureTime = 0;
+  state = "CLOSED";
+  config;
+  constructor(config) {
+    this.config = config;
   }
-  validate(definition) {
-    return __async(this, null, function* () {
-      const body = ModelDefinitionSchema.parse(definition);
-      return this.http.post("/ontology/engine/ontologies/validate", body);
-    });
+  /** Returns the current circuit state. */
+  getState() {
+    return this.state;
   }
-  checkIntegrity() {
-    return __async(this, null, function* () {
-      return this.http.get("/ontology/engine/health");
-    });
+  /** Returns the current consecutive failure count. */
+  getFailures() {
+    return this.failures;
+  }
+  reset() {
+    this.failures = 0;
+    this.state = "CLOSED";
+    this.config.onClose?.();
+  }
+  /**
+   * Executes an async function through the circuit breaker.
+   * Throws CircuitBreakerOpenError immediately if the circuit is OPEN
+   * and the reset timeout has not elapsed. On success in HALF_OPEN state,
+   * resets the circuit to CLOSED.
+   *
+   * @param fn - The async operation to protect.
+   * @throws {CircuitBreakerOpenError} If the circuit is OPEN.
+   */
+  async execute(fn) {
+    if (this.state === "OPEN") {
+      if (Date.now() - this.lastFailureTime > this.config.resetTimeoutMs) {
+        this.state = "HALF_OPEN";
+        this.config.onHalfOpen?.();
+      } else {
+        throw new CircuitBreakerOpenError(
+          this.config.resetTimeoutMs - (Date.now() - this.lastFailureTime)
+        );
+      }
+    }
+    try {
+      const result = await fn();
+      if (this.state === "HALF_OPEN") {
+        this.reset();
+      }
+      return result;
+    } catch (error) {
+      this.failures++;
+      this.lastFailureTime = Date.now();
+      if (this.failures >= this.config.failureThreshold) {
+        this.state = "OPEN";
+        this.config.onOpen?.();
+      }
+      throw error;
+    }
+  }
+  /** Manually forces the circuit into the OPEN state. */
+  forceOpen() {
+    this.state = "OPEN";
+    this.lastFailureTime = Date.now();
+  }
+  /** Manually resets the circuit to the CLOSED state. */
+  forceClose() {
+    this.reset();
   }
 };
-var ModelAccessor = class {
-  constructor(_name, http) {
-    this._name = _name;
-    this.http = http;
+var CircuitBreakerOpenError = class extends Error {
+  /** Milliseconds remaining until the circuit transitions to HALF_OPEN. */
+  retryAfterMs;
+  constructor(retryAfterMs) {
+    super(
+      `Circuit breaker is open \u2014 retry after ${Math.ceil(retryAfterMs / 1e3)}s`
+    );
+    this.name = "CircuitBreakerOpenError";
+    this.retryAfterMs = retryAfterMs;
+    Object.setPrototypeOf(this, new.target.prototype);
   }
-  get(version) {
-    return __async(this, null, function* () {
-      const params = version ? { version } : void 0;
-      return this.http.get("/ontology/engine/runs", params);
-    });
+};
+function computeBaseDelay(attempt, strategy, baseDelay) {
+  const normalizedAttempt = Math.floor(attempt);
+  switch (strategy) {
+    case "linear":
+      return Math.max(0, baseDelay * (normalizedAttempt + 1));
+    case "constant":
+      return baseDelay;
+    default:
+      return baseDelay * EXPONENTIAL_BASE ** normalizedAttempt;
   }
-  update(definition) {
-    return __async(this, null, function* () {
-      return this.http.post("/ontology/engine/runs", definition);
-    });
+}
+function calculateDelay(attempt, strategyOrConfig, baseDelay, withJitter = false) {
+  if (typeof strategyOrConfig === "object") {
+    const strategy = "strategy" in strategyOrConfig ? strategyOrConfig.strategy : strategyOrConfig.backoff;
+    const delayBase = "baseDelay" in strategyOrConfig ? strategyOrConfig.baseDelay : strategyOrConfig.retryDelay;
+    const delay2 = computeBaseDelay(attempt, strategy, delayBase);
+    const shouldJitter = "jitter" in strategyOrConfig ? Boolean(strategyOrConfig.jitter) : true;
+    if (!shouldJitter) return delay2;
+    return delay2 + Math.random() * (JITTER_MAX / 2);
   }
-  delete(force = false) {
-    return __async(this, null, function* () {
-      return this.http.post("/ontology/engine/runs", {
-        action: "delete-model",
-        force
+  const delay = computeBaseDelay(
+    attempt,
+    strategyOrConfig,
+    Math.max(0, baseDelay ?? 0)
+  );
+  if (!withJitter) return delay;
+  return delay + Math.random() * (JITTER_MAX / 2);
+}
+function snakeToCamel(str) {
+  const prefix = str.match(/^_+/)?.[0] ?? "";
+  const body = str.slice(prefix.length);
+  if (!body) return str;
+  return prefix + body.replace(/_([a-z0-9])/g, (_, c) => c.toUpperCase());
+}
+function camelToSnake(str) {
+  return str.replace(/([A-Z]+)([A-Z][a-z])/g, "$1_$2").replace(/([a-z0-9])([A-Z])/g, "$1_$2").toLowerCase();
+}
+var NEVER_TRANSFORM_KEYS = /* @__PURE__ */ new Set(["$ref", "$schema", "$id"]);
+function isStream(obj) {
+  return typeof obj === "object" && obj !== null && (typeof obj.pipe === "function" || typeof obj.getReader === "function");
+}
+function deepTransformKeys(obj, transform, skipKeys) {
+  if (obj === null || obj === void 0) return obj;
+  if (typeof obj !== "object") return obj;
+  if (obj instanceof Date || typeof Buffer !== "undefined" && obj instanceof Buffer || obj instanceof RegExp || obj instanceof FormData || obj instanceof File || obj instanceof Blob)
+    return obj;
+  if (isStream(obj)) return obj;
+  if (Array.isArray(obj)) {
+    return obj.map(
+      (item) => deepTransformKeys(item, transform, skipKeys)
+    );
+  }
+  const proto = Object.getPrototypeOf(obj);
+  if (proto !== Object.prototype && proto !== null) return obj;
+  const result = {};
+  for (const key of Object.keys(obj)) {
+    const shouldSkip = skipKeys?.has(key) || NEVER_TRANSFORM_KEYS.has(key);
+    const newKey = shouldSkip ? key : transform(key);
+    result[newKey] = deepTransformKeys(
+      obj[key],
+      transform,
+      skipKeys
+    );
+  }
+  return result;
+}
+function deepCamelToSnake(obj, skipKeys) {
+  return deepTransformKeys(obj, camelToSnake, skipKeys);
+}
+function deepSnakeToCamel(obj, skipKeys) {
+  return deepTransformKeys(obj, snakeToCamel, skipKeys);
+}
+var HttpClient = class {
+  constructor(config) {
+    this.config = config;
+    if (config.circuitBreaker) {
+      this.breaker = new CircuitBreaker({
+        failureThreshold: config.circuitBreaker.failureThreshold,
+        resetTimeoutMs: config.circuitBreaker.resetTimeoutMs
       });
+    }
+  }
+  breaker;
+  /**
+   * Sends a GET request.
+   * @param path - API endpoint path.
+   * @param params - Optional query parameters.
+   * @param schema - Optional Zod schema for response validation.
+   */
+  async get(path, params, schema) {
+    return this.request("GET", path, void 0, params, schema);
+  }
+  /**
+   * Sends a POST request with a JSON body.
+   * @param path - API endpoint path.
+   * @param body - Request payload (converted to snake_case automatically).
+   * @param schema - Optional Zod schema for response validation.
+   */
+  async post(path, body, schema) {
+    return this.request("POST", path, body ?? {}, void 0, schema);
+  }
+  /**
+   * Sends a PUT request with a JSON body.
+   * @param path - API endpoint path.
+   * @param body - Request payload (converted to snake_case automatically).
+   * @param schema - Optional Zod schema for response validation.
+   */
+  async put(path, body, schema) {
+    return this.request("PUT", path, body ?? {}, void 0, schema);
+  }
+  /**
+   * Sends a PATCH request with a JSON body.
+   * @param path - API endpoint path.
+   * @param body - Request payload (converted to snake_case automatically).
+   * @param schema - Optional Zod schema for response validation.
+   */
+  async patch(path, body, schema) {
+    return this.request("PATCH", path, body ?? {}, void 0, schema);
+  }
+  /**
+   * Sends a DELETE request.
+   * @param path - API endpoint path.
+   * @param params - Optional query parameters.
+   * @param schema - Optional Zod schema for response validation.
+   */
+  async delete(path, params, schema) {
+    return this.request("DELETE", path, {}, params, schema);
+  }
+  /**
+   * Sends a raw PUT request with a binary/stream body.
+   * @param path - API endpoint path.
+   * @param body - Binary buffer or readable stream.
+   * @param contentType - MIME type of the body.
+   * @param headers - Additional request headers.
+   * @returns The parsed JSON response with keys converted to camelCase.
+   */
+  async putRaw(path, body, contentType, headers = {}) {
+    const url = this.buildUrl(path);
+    const res = await this.fetchWithTimeout(url, {
+      method: "PUT",
+      headers: this.buildHeaders({ "Content-Type": contentType, ...headers }),
+      body
     });
+    if (!res.ok) await this.throwError(res);
+    if (res.status === 204) return void 0;
+    const json = await res.json();
+    return typeof json === "object" && json !== null ? deepSnakeToCamel(json) : json;
   }
-  relationships() {
-    return __async(this, null, function* () {
-      return this.http.get("/ontology/engine/runs");
+  /**
+   * Opens a GET SSE stream, yielding parsed server-sent events.
+   * @param path - API endpoint path.
+   * @param params - Optional query parameters.
+   * @yields SSE event objects with `type`, `data`, and optional `id` fields.
+   */
+  async *stream(path, params) {
+    const url = this.buildUrl(path, params);
+    const res = await this.fetchWithTimeout(url, {
+      method: "GET",
+      headers: this.buildHeaders({ Accept: "text/event-stream" })
     });
+    if (!res.ok) await this.throwError(res);
+    yield* this.parseSSEResponse(res);
   }
-  addRelationship(definition) {
-    return __async(this, null, function* () {
-      const body = RelationshipDefinitionSchema.parse(definition);
-      return this.http.post("/ontology/engine/runs", body);
+  /**
+   * Sends a POST request that returns an SSE stream.
+   * @param path - API endpoint path.
+   * @param body - Request payload (converted to snake_case automatically).
+   * @yields SSE event objects with `type`, `data`, and optional `id` fields.
+   */
+  async *postStream(path, body) {
+    const url = this.buildUrl(path);
+    const res = await this.fetchWithTimeout(url, {
+      method: "POST",
+      headers: this.buildHeaders({ Accept: "text/event-stream" }),
+      body: JSON.stringify(body ?? {})
     });
+    if (!res.ok) await this.throwError(res);
+    yield* this.parseSSEResponse(res);
   }
-  removeRelationship(relationshipId) {
-    return __async(this, null, function* () {
-      return this.http.post("/ontology/engine/runs", {
-        action: "delete-relationship",
-        relationshipId
-      });
+  /**
+   * Sends a POST request and returns the raw Response object.
+   * @param path - API endpoint path.
+   * @param body - Request payload.
+   * @param headers - Additional request headers.
+   * @returns The raw fetch Response (caller must handle parsing).
+   */
+  async postRaw(path, body, headers = {}) {
+    const url = this.buildUrl(path);
+    const res = await this.fetchWithTimeout(url, {
+      method: "POST",
+      headers: new Headers(this.buildHeaders(headers)),
+      body: JSON.stringify(body ?? {})
     });
+    if (!res.ok) await this.throwError(res);
+    return res;
   }
-  validateData() {
-    return __async(this, null, function* () {
-      return this.http.post("/ontology/engine/ontologies/validate");
+  /**
+   * Sends a POST request with a FormData body (multipart/form-data).
+   * Automatically removes the Content-Type header so the browser sets the
+   * correct multipart boundary.
+   * @param path - API endpoint path.
+   * @param formData - FormData payload.
+   * @param headers - Additional request headers.
+   * @returns The parsed JSON response with keys converted to camelCase.
+   */
+  async postFormData(path, formData, headers = {}) {
+    const url = this.buildUrl(path);
+    const merged = new Headers(this.buildHeaders(headers));
+    merged.delete("Content-Type");
+    const res = await this.fetchWithTimeout(url, {
+      method: "POST",
+      headers: merged,
+      body: formData
     });
+    if (!res.ok) await this.throwError(res);
+    const json = await res.json();
+    return deepSnakeToCamel(json);
   }
-  versions() {
-    return __async(this, null, function* () {
-      return this.http.get("/ontology/engine/runs");
+  /**
+   * Sends a raw GET request and returns the Response object directly.
+   * @param path - API endpoint path.
+   * @param params - Optional query parameters.
+   * @param headers - Additional request headers.
+   * @returns The raw fetch Response (caller must handle parsing).
+   */
+  async getRaw(path, params, headers = {}) {
+    const url = this.buildUrl(path, params);
+    const res = await this.fetchWithTimeout(url, {
+      method: "GET",
+      headers: this.buildHeaders(headers)
     });
+    if (!res.ok) await this.throwError(res);
+    return res;
+  }
+  async *parseSSEResponse(res) {
+    if (!res.body) return;
+    const reader = res.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split("\n");
+      buffer = lines.pop() ?? "";
+      let event = {
+        type: "message",
+        data: null
+      };
+      for (const rawLine of lines) {
+        const line = rawLine.trimEnd();
+        if (line.startsWith("id:")) {
+          event.id = line.slice(3).trim();
+        } else if (line.startsWith("event:")) {
+          event.type = line.slice(6).trim();
+        } else if (line.startsWith("data:")) {
+          const payload = line.slice(5).trim();
+          try {
+            const parsed = JSON.parse(payload);
+            event.data = typeof parsed === "object" && parsed !== null ? deepSnakeToCamel(parsed) : parsed;
+          } catch {
+            event.data = payload;
+          }
+        } else if (line === "") {
+          if (event.data !== null) yield event;
+          event = { type: "message", data: null };
+        }
+      }
+    }
+  }
+  async request(method, path, body, params, schema, attempt = 0) {
+    const url = this.buildUrl(path, params);
+    const requestId = crypto.randomUUID();
+    const transformedBody = body !== void 0 && body !== null ? deepCamelToSnake(body) : body;
+    const reqInit = {
+      method,
+      headers: this.buildHeaders({ "X-Request-Id": requestId }),
+      ...method !== "GET" ? { body: JSON.stringify(transformedBody ?? {}) } : { body: void 0 }
+    };
+    this.config.logger?.request?.(method, url, reqInit);
+    const executeRequest = async () => {
+      try {
+        return await this.fetchWithTimeout(url, reqInit);
+      } catch (error) {
+        this.config.logger?.error?.(error);
+        throw new NetworkError(error);
+      }
+    };
+    let res;
+    try {
+      res = this.breaker ? await this.breaker.execute(executeRequest) : await executeRequest();
+    } catch (error) {
+      if (error instanceof CircuitBreakerOpenError) {
+        throw new Error(
+          `Circuit breaker is open. Retry after ${Math.ceil(error.retryAfterMs / 1e3)}s.`
+        );
+      }
+      throw error;
+    }
+    this.config.logger?.response?.(res);
+    if (!res.ok) {
+      const shouldRetry = [429, 500, 502, 503, 504].includes(res.status) && attempt < this.config.maxRetries;
+      if (shouldRetry) {
+        const retryAfterValue = res.headers.get("Retry-After");
+        const retryAfterSeconds = retryAfterValue ? Number.parseInt(retryAfterValue, 10) : Number.NaN;
+        const delay = Number.isFinite(retryAfterSeconds) ? retryAfterSeconds * 1e3 : calculateDelay(
+          attempt,
+          "exponential",
+          this.config.retryDelay,
+          true
+        );
+        await sleep(delay);
+        return this.request(method, path, body, params, schema, attempt + 1);
+      }
+      await this.throwError(res);
+    }
+    if (res.status === 204) return void 0;
+    const contentType = (res.headers.get("content-type") || "").toLowerCase();
+    const payload = contentType.includes("application/json") ? await res.json() : await res.text();
+    const transformedPayload = typeof payload === "object" && payload !== null ? deepSnakeToCamel(payload) : payload;
+    if (schema) {
+      try {
+        const parsed = schema.safeParse(transformedPayload);
+        if (!parsed.success) {
+          this.config.logger?.error?.(parsed.error);
+          throw parsed.error;
+        }
+        return parsed.data;
+      } catch (error) {
+        if (error instanceof Error && error.message.includes("_zod")) {
+          return transformedPayload;
+        }
+        throw error;
+      }
+    }
+    return transformedPayload;
+  }
+  parseRateLimit(res) {
+    const limit = res.headers.get("X-RateLimit-Limit");
+    const remaining = res.headers.get("X-RateLimit-Remaining");
+    const reset = res.headers.get("X-RateLimit-Reset");
+    if (limit && remaining && reset) {
+      return {
+        limit: Number.parseInt(limit, 10),
+        remaining: Number.parseInt(remaining, 10),
+        reset: Number.parseInt(reset, 10)
+      };
+    }
+    return void 0;
+  }
+  async throwError(res) {
+    let body;
+    try {
+      body = await res.json();
+    } catch {
+      body = {};
+    }
+    const retryAfter = res.headers.get("Retry-After") ?? void 0;
+    const rateLimit = this.parseRateLimit(res);
+    throw parseFrontalError(body, res.status, retryAfter, rateLimit);
+  }
+  buildUrl(path, params) {
+    const base = this.config.baseUrl.replace(/\/$/, "");
+    let normalizedPath = path.startsWith("/") ? path : `/${path}`;
+    if (base.endsWith("/v1") && normalizedPath.startsWith("/v1/")) {
+      if (this.config.debug) {
+        console.warn(
+          `[SDK] Double /v1/ prefix detected and normalized. The base URL already includes "/v1" but the route "${normalizedPath}" also starts with "/v1/". Write routes without a leading "/v1".`
+        );
+      }
+      normalizedPath = normalizedPath.slice("/v1".length);
+    }
+    const url = `${base}${normalizedPath}`;
+    const transformedParams = params ? deepCamelToSnake(params) : params;
+    if (!transformedParams || Object.keys(transformedParams).length === 0) {
+      return url;
+    }
+    const query = Object.entries(transformedParams).filter(([, value]) => value !== void 0 && value !== null).map(
+      ([key, value]) => `${encodeURIComponent(key)}=${encodeURIComponent(String(value))}`
+    ).join("&");
+    return query ? `${url}?${query}` : url;
+  }
+  buildHeaders(extra = {}) {
+    return {
+      // The opaque API key (`frt_…`) is the sole public credential. The platform
+      // edge validates it and exchanges it for a short-lived JWT before reaching
+      // any service — the SDK never sees or sends a JWT.
+      Authorization: `Bearer ${this.config.apiKey}`,
+      "Content-Type": "application/json",
+      Accept: "application/json",
+      "User-Agent": "@frontal-labs/core",
+      "X-Frontal-Core": `typescript@${SDK_VERSION}`,
+      "X-Frontal-Environment": this.config.environment,
+      ...this.config.headers,
+      ...extra
+    };
+  }
+  async fetchWithTimeout(url, init) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), this.config.timeout);
+    try {
+      return await (this.config.fetch ?? fetch)(url, {
+        ...init,
+        signal: controller.signal
+      });
+    } finally {
+      clearTimeout(timer);
+    }
   }
 };
-var MigrationsNamespace = class {
-  constructor(http) {
-    this.http = http;
+var sleep = async (ms) => new Promise((resolve) => {
+  setTimeout(resolve, ms);
+});
+var apiKeySchema = z2.string().min(9, "FRONTAL_API_KEY must be at least 9 characters").max(128, "FRONTAL_API_KEY must be at most 128 characters").refine(
+  (val) => /^frt_[A-Za-z0-9_]+$/.test(val) || /^fr_typed[A-Za-z0-9_]+$/.test(val),
+  "FRONTAL_API_KEY must start with frt_"
+);
+var debugSchema = z2.union([
+  z2.literal("true"),
+  z2.literal("false"),
+  z2.literal("1"),
+  z2.literal("0")
+]).optional().default("false").transform((val) => val === "true" || val === "1");
+var env = createEnv({
+  server: {
+    FRONTAL_ENV: z2.enum(["development", "test", "production"]).default("development"),
+    FRONTAL_API_KEY: apiKeySchema.optional(),
+    FRONTAL_API_URL: z2.url("FRONTAL_API_URL must be a valid URL").optional(),
+    FRONTAL_DEBUG: debugSchema
+  },
+  runtimeEnv: {
+    FRONTAL_ENV: process.env.FRONTAL_ENV,
+    FRONTAL_API_KEY: process.env.FRONTAL_API_KEY,
+    FRONTAL_API_URL: process.env.FRONTAL_API_URL,
+    FRONTAL_DEBUG: process.env.FRONTAL_DEBUG
+  },
+  emptyStringAsUndefined: true
+});
+var unwrapClientError = (error) => {
+  if (error instanceof NetworkError) {
+    if (error.cause instanceof Error) {
+      throw error.cause;
+    }
+    throw new Error(String(error.cause));
   }
-  plan(request) {
-    return __async(this, null, function* () {
-      return this.http.post(
-        "/ontology/engine/ontologies/compare-versions",
-        request
-      );
+  throw error;
+};
+var FrontalClient = class {
+  config;
+  _http;
+  /**
+   * @param config - Validated client configuration output from clientConfigSchema.
+   */
+  constructor(config) {
+    Object.defineProperty(this, "config", {
+      value: config,
+      writable: false,
+      enumerable: true
     });
-  }
-  apply(planId, strategy = "zero-downtime") {
-    return __async(this, null, function* () {
-      return this.http.post("/ontology/engine/runs", { planId, strategy });
+    const http = new HttpClient(config);
+    Object.defineProperty(this, "_http", {
+      value: http,
+      writable: false,
+      enumerable: true
     });
-  }
-  rollback(_migrationId) {
-    return __async(this, null, function* () {
-      return this.http.post("/ontology/engine/runs");
+    Object.defineProperty(this, "httpClient", {
+      get() {
+        return http;
+      },
+      enumerable: true
     });
   }
-  history() {
-    return __async(this, arguments, function* (opts = {}) {
-      const raw = yield this.http.get("/ontology/engine/runs", opts);
-      return createPageResult(
-        asPagePayload(raw),
-        (cursor) => this.history(__spreadProps(__spreadValues({}, opts), { cursor }))
-      );
-    });
+  /** Public accessor for the underlying HttpClient. */
+  get httpClient() {
+    return this._http;
+  }
+  /**
+   * Sends a GET request and optionally validates the response against a schema.
+   * @param path - API endpoint path.
+   * @param schema - Optional Zod schema for response validation.
+   */
+  async get(path, schema) {
+    try {
+      return await this._http.get(path, void 0, schema);
+    } catch (error) {
+      throw unwrapClientError(error);
+    }
+  }
+  /**
+   * Sends a POST request with an optional JSON body and response schema.
+   * @param path - API endpoint path.
+   * @param body - Request payload (converted to snake_case automatically).
+   * @param schema - Optional Zod schema for response validation.
+   */
+  async post(path, body, schema) {
+    try {
+      return await this._http.post(path, body, schema);
+    } catch (error) {
+      throw unwrapClientError(error);
+    }
+  }
+  /**
+   * Sends a PUT request with an optional JSON body and response schema.
+   * @param path - API endpoint path.
+   * @param body - Request payload (converted to snake_case automatically).
+   * @param schema - Optional Zod schema for response validation.
+   */
+  async put(path, body, schema) {
+    try {
+      return await this._http.put(path, body, schema);
+    } catch (error) {
+      throw unwrapClientError(error);
+    }
+  }
+  /**
+   * Sends a PATCH request with an optional JSON body and response schema.
+   * @param path - API endpoint path.
+   * @param body - Request payload (converted to snake_case automatically).
+   * @param schema - Optional Zod schema for response validation.
+   */
+  async patch(path, body, schema) {
+    try {
+      return await this._http.patch(path, body, schema);
+    } catch (error) {
+      throw unwrapClientError(error);
+    }
+  }
+  /**
+   * Sends a DELETE request with optional query parameters and response schema.
+   * @param path - API endpoint path.
+   * @param params - Query parameters (converted to snake_case automatically).
+   * @param schema - Optional Zod schema for response validation.
+   */
+  async delete(path, params, schema) {
+    try {
+      return await this._http.delete(path, params, schema);
+    } catch (error) {
+      throw unwrapClientError(error);
+    }
+  }
+  /**
+   * Opens a GET SSE stream and yields parsed server-sent events.
+   * @param path - API endpoint path.
+   * @param params - Optional query parameters.
+   * @yields Objects with `type`, `data`, and optional `id` fields from SSE events.
+   */
+  async *stream(path, params) {
+    try {
+      yield* this._http.stream(path, params);
+    } catch (error) {
+      throw unwrapClientError(error);
+    }
+  }
+  /**
+   * Sends a raw PUT request with a binary/stream body and custom content type.
+   * @param path - API endpoint path.
+   * @param body - Binary buffer or readable stream to upload.
+   * @param contentType - MIME type of the body.
+   * @param headers - Additional request headers.
+   * @returns The parsed JSON response (keys converted to camelCase).
+   */
+  async putRaw(path, body, contentType, headers = {}) {
+    try {
+      return await this._http.putRaw(path, body, contentType, headers);
+    } catch (error) {
+      throw unwrapClientError(error);
+    }
   }
 };
-var RulesNamespace = class {
+var getDefaultClient = () => {
+  if (!env.FRONTAL_API_KEY) {
+    throw new Error(
+      "FRONTAL_API_KEY environment variable is required. Set it in your environment or pass apiKey explicitly to new FrontalClient()."
+    );
+  }
+  return new FrontalClient({
+    apiKey: env.FRONTAL_API_KEY,
+    baseUrl: env.FRONTAL_API_URL ?? DEFAULT_BASE_URL,
+    timeout: 3e4,
+    maxRetries: 3,
+    retryDelay: 1e3,
+    headers: {},
+    environment: env.FRONTAL_ENV,
+    debug: env.FRONTAL_DEBUG
+  });
+};
+var API_KEY_PATTERN = new RegExp(`^${API_KEY_PREFIX}[A-Za-z0-9_-]+$`);
+var loggerFnSchema = z3.custom(
+  (value) => typeof value === "function",
+  "Expected function"
+);
+var headersSchema = z3.record(z3.string(), z3.string()).superRefine((headers, ctx) => {
+  for (const key of Object.keys(headers)) {
+    if (key.trim().length === 0) {
+      ctx.addIssue({
+        code: z3.ZodIssueCode.custom,
+        message: "Header names must be non-empty",
+        path: []
+      });
+      return;
+    }
+  }
+}).default({});
+var clientConfigSchema = z3.object({
+  apiKey: z3.string().min(9, "apiKey is required").regex(API_KEY_PATTERN, `apiKey must start with "${API_KEY_PREFIX}"`),
+  baseUrl: z3.string().url().refine(
+    (value) => value.startsWith("https://") || value.startsWith("http://"),
+    {
+      message: "baseUrl must use http or https"
+    }
+  ).default(DEFAULT_BASE_URL),
+  timeout: z3.number().int().positive().default(3e4),
+  maxRetries: z3.number().int().min(0).max(10).default(3),
+  retryDelay: z3.number().int().positive().default(1e3),
+  headers: headersSchema,
+  environment: z3.string().default("production"),
+  debug: z3.boolean().default(false),
+  fetch: z3.custom((value) => typeof value === "function").optional(),
+  logger: z3.object({
+    request: loggerFnSchema.optional(),
+    response: loggerFnSchema.optional(),
+    error: loggerFnSchema.optional()
+  }).optional(),
+  circuitBreaker: z3.object({
+    failureThreshold: z3.number().int().positive().default(5),
+    resetTimeoutMs: z3.number().int().positive().default(3e4)
+  }).optional()
+}).strict();
+function asPagePayload(raw) {
+  return raw;
+}
+var paginationSchema = z4.object({
+  cursor: z4.string().min(1),
+  hasMore: z4.boolean(),
+  total: z4.number().int().min(0).optional(),
+  limit: z4.number().int().positive().optional(),
+  offset: z4.number().int().min(0).optional()
+}).strict();
+function buildPageResult(data, pagination, fetchNext, meta) {
+  let nextPagePromise = null;
+  const page = {
+    data,
+    meta,
+    pagination,
+    _fetchNextPage: fetchNext,
+    async nextPage() {
+      if (!this.pagination.hasMore) return null;
+      if (!nextPagePromise) {
+        nextPagePromise = (async () => {
+          let result = await this._fetchNextPage();
+          if (!result && this._fallbackFetchNextPage) {
+            result = await this._fallbackFetchNextPage();
+          }
+          if (result) {
+            const mutableResult = result;
+            mutableResult._fallbackFetchNextPage = this._fallbackFetchNextPage ?? this._fetchNextPage;
+          }
+          return result;
+        })().finally(() => {
+          nextPagePromise = null;
+        });
+      }
+      return nextPagePromise;
+    },
+    async all() {
+      const items = [...this.data];
+      let current = this;
+      while (current) {
+        if (!current.pagination.hasMore) break;
+        current = await current.nextPage();
+        if (!current) break;
+        items.push(...current.data);
+      }
+      return items;
+    },
+    [Symbol.asyncIterator]() {
+      let current = this;
+      let index = 0;
+      return {
+        async next() {
+          while (current) {
+            if (index < current.data.length) {
+              return { done: false, value: current.data[index++] };
+            }
+            if (!current.pagination.hasMore) {
+              current = null;
+              break;
+            }
+            current = await current.nextPage();
+            index = 0;
+          }
+          return { done: true, value: void 0 };
+        }
+      };
+    }
+  };
+  return page;
+}
+function createPageResult(dataOrRaw, paginationOrFetchNext, fetchNextOrMeta, meta) {
+  if (Array.isArray(dataOrRaw)) {
+    const data = dataOrRaw;
+    const pagination = paginationOrFetchNext;
+    const fetchNextPage2 = fetchNextOrMeta;
+    const fetchNext2 = async () => {
+      if (!fetchNextPage2) return null;
+      return fetchNextPage2.length > 0 ? fetchNextPage2(
+        pagination.cursor
+      ) : fetchNextPage2();
+    };
+    return buildPageResult(data, pagination, fetchNext2, meta);
+  }
+  const raw = dataOrRaw;
+  const fetchNextPage = paginationOrFetchNext;
+  const fetchNext = async () => {
+    if (!fetchNextPage) return null;
+    return fetchNextPage.length > 0 ? fetchNextPage(
+      raw.pagination.cursor
+    ) : fetchNextPage();
+  };
+  return buildPageResult(
+    Array.isArray(raw.data) ? raw.data : [],
+    raw.pagination,
+    fetchNext,
+    raw.meta
+  );
+}
+
+// src/constants.ts
+var DEFAULT_ONTOLOGY_BASE_URL = "https://api.frontal.dev/v1";
+var VERSION = "0.0.1";
+var DEFAULT_TIMEOUT = 3e4;
+var DEFAULT_MAX_RETRIES = 3;
+var DEFAULT_RETRY_DELAY = 1e3;
+
+// src/sdk.ts
+var OntologySdk = class {
+  engine;
+  objects;
+  relationships;
+  schemas;
+  versions;
+  validation;
+  transformations;
+  reasoning;
+  rollouts;
+  rollups;
+  extract;
+  events;
+  /**
+   * @param http - The HTTP client used to make API requests.
+   */
   constructor(http) {
+    this.engine = new EngineNamespace(http);
+    this.objects = new ObjectsNamespace(http);
+    this.relationships = new RelationshipsNamespace(http);
+    this.schemas = new SchemasNamespace(http);
+    this.versions = new VersionsNamespace(http);
+    this.validation = new ValidationNamespace(http);
+    this.transformations = new TransformationsNamespace(http);
+    this.reasoning = new ReasoningNamespace(http);
+    this.rollouts = new RolloutsNamespace(http);
+    this.rollups = new RollupsNamespace(http);
+    this.extract = new ExtractNamespace(http);
+    this.events = new EventsNamespace(http);
+  }
+};
+var SubdomainBase = class {
+  constructor(http, base) {
     this.http = http;
+    this.base = base;
   }
-  list() {
-    return __async(this, null, function* () {
-      return this.http.get("/ontology/engine/runs");
-    });
+  /**
+   * Returns the capabilities of this subdomain service.
+   */
+  capabilities() {
+    return this.http.get(`${this.base}/capabilities`);
   }
-  create(definition) {
-    return __async(this, null, function* () {
-      const body = RuleDefinitionSchema.parse(definition);
-      return this.http.post("/ontology/engine/runs", body);
-    });
+  /**
+   * Health check for this subdomain service.
+   */
+  health() {
+    return this.http.get(`${this.base}/health`);
   }
-  update(_ruleId, definition) {
-    return __async(this, null, function* () {
-      return this.http.post("/ontology/engine/runs", definition);
-    });
+  /**
+   * Returns service info/metadata for this subdomain service.
+   */
+  info() {
+    return this.http.get(`${this.base}/info`);
   }
-  delete(ruleId) {
-    return __async(this, null, function* () {
-      return this.http.post("/ontology/engine/runs", {
-        action: "delete-rule",
-        ruleId
-      });
-    });
+  /**
+   * Lists asynchronous runs for this subdomain.
+   * @param opts - Pagination options.
+   */
+  async runs(opts = {}) {
+    const raw = await this.http.get(`${this.base}/runs`, opts);
+    return createPageResult(
+      asPagePayload(raw),
+      (c) => this.runs({ ...opts, cursor: c })
+    );
   }
-  evaluate(opts) {
-    return __async(this, null, function* () {
-      return this.http.post("/ontology/engine/ontologies/validate", opts);
-    });
+  /**
+   * Creates a new asynchronous run.
+   * @param input - The run input payload.
+   */
+  createRun(input) {
+    return this.http.post(`${this.base}/runs`, input);
+  }
+  /**
+   * Fetches an asynchronous run by ID.
+   * @param runId - The run ID.
+   */
+  run(runId) {
+    return this.http.get(`${this.base}/runs/${runId}`);
   }
 };
-var MixinsNamespace = class {
+var EngineNamespace = class extends SubdomainBase {
   constructor(http) {
-    this.http = http;
+    super(http, "/ontology/engine");
   }
-  list() {
-    return __async(this, null, function* () {
-      return this.http.get("/ontology/engine/runs");
-    });
+  /**
+   * Generates an ontology from a description.
+   * @param input - Generation parameters.
+   */
+  generate(input) {
+    return this.http.post("/ontology/engine/ontologies/generate", input);
   }
-  create(definition) {
-    return __async(this, null, function* () {
-      const body = MixinDefinitionSchema.parse(definition);
-      return this.http.post("/ontology/engine/runs", body);
-    });
+  /**
+   * Validates an ontology definition.
+   * @param input - The ontology to validate.
+   */
+  validate(input) {
+    return this.http.post("/ontology/engine/ontologies/validate", input);
+  }
+  /**
+   * Exports an ontology in a standard format.
+   * @param input - Export parameters.
+   */
+  export(input) {
+    return this.http.post("/ontology/engine/ontologies/export", input);
+  }
+  /**
+   * Exports an ontology as SHACL shapes.
+   * @param input - Export parameters.
+   */
+  exportShacl(input) {
+    return this.http.post("/ontology/engine/ontologies/export-shacl", input);
+  }
+  /**
+   * Infers class definitions from source data.
+   * @param input - Inference parameters.
+   */
+  inferClasses(input) {
+    return this.http.post("/ontology/engine/ontologies/infer-classes", input);
+  }
+  /**
+   * Infers property definitions from source data.
+   * @param input - Inference parameters.
+   */
+  inferProperties(input) {
+    return this.http.post(
+      "/ontology/engine/ontologies/infer-properties",
+      input
+    );
+  }
+  /**
+   * Compares two ontology versions.
+   * @param input - Comparison parameters (fromVersion, toVersion).
+   */
+  compareVersions(input) {
+    return this.http.post(
+      "/ontology/engine/ontologies/compare-versions",
+      input
+    );
   }
 };
-var GenerationNamespace = class {
+var ObjectsNamespace = class extends SubdomainBase {
   constructor(http) {
-    this.http = http;
+    super(http, "/ontology/objects");
   }
-  generate(description, opts) {
-    return __async(this, null, function* () {
-      return this.http.post("/ontology/engine/ontologies/generate", __spreadValues({
-        description
-      }, opts));
-    });
+  /**
+   * Lists object types with pagination.
+   * @param opts - Pagination options.
+   */
+  async listObjectTypes(opts = {}) {
+    const raw = await this.http.get("/ontology/objects/object-types", opts);
+    return createPageResult(
+      asPagePayload(raw),
+      (c) => this.listObjectTypes({ ...opts, cursor: c })
+    );
   }
-  infer(opts) {
-    return __async(this, null, function* () {
-      return this.http.post("/ontology/engine/ontologies/infer-classes", opts);
-    });
+  /**
+   * Fetches an object type by ID.
+   * @param id - The object type ID.
+   */
+  getObjectType(id) {
+    return this.http.get(`/ontology/objects/object-types/${id}`);
   }
-  suggestions() {
-    return __async(this, arguments, function* (opts = {}) {
-      return this.http.get("/ontology/engine/runs", opts);
-    });
+  /**
+   * Creates or updates an object type.
+   * @param id - The object type ID.
+   * @param body - The object type definition.
+   */
+  putObjectType(id, body) {
+    return this.http.put(`/ontology/objects/object-types/${id}`, body);
   }
-  acceptSuggestion(_suggestionId) {
-    return __async(this, null, function* () {
-      return this.http.post("/ontology/engine/runs");
-    });
+  /**
+   * Deletes an object type.
+   * @param id - The object type ID.
+   */
+  deleteObjectType(id) {
+    return this.http.delete(`/ontology/objects/object-types/${id}`);
   }
-  rejectSuggestion(_suggestionId, reason) {
-    return __async(this, null, function* () {
-      return this.http.post("/ontology/engine/runs", {
-        reason
-      });
-    });
+  /**
+   * Lists object instances with pagination.
+   * @param opts - Pagination options.
+   */
+  async listObjects(opts = {}) {
+    const raw = await this.http.get("/ontology/objects/objects", opts);
+    return createPageResult(
+      asPagePayload(raw),
+      (c) => this.listObjects({ ...opts, cursor: c })
+    );
+  }
+  /**
+   * Fetches an object instance by ID.
+   * @param id - The object ID.
+   */
+  getObject(id) {
+    return this.http.get(`/ontology/objects/objects/${id}`);
+  }
+  /**
+   * Creates or updates an object instance.
+   * @param id - The object ID.
+   * @param body - The object data.
+   */
+  putObject(id, body) {
+    return this.http.put(`/ontology/objects/objects/${id}`, body);
+  }
+  /**
+   * Deletes an object instance.
+   * @param id - The object ID.
+   */
+  deleteObject(id) {
+    return this.http.delete(`/ontology/objects/objects/${id}`);
+  }
+};
+var RelationshipsNamespace = class extends SubdomainBase {
+  constructor(http) {
+    super(http, "/ontology/relationships");
+  }
+  /**
+   * Lists relationship types with pagination.
+   * @param opts - Pagination options.
+   */
+  async listTypes(opts = {}) {
+    const raw = await this.http.get(
+      "/ontology/relationships/relationship-types",
+      opts
+    );
+    return createPageResult(
+      asPagePayload(raw),
+      (c) => this.listTypes({ ...opts, cursor: c })
+    );
+  }
+  /**
+   * Deletes a relationship type.
+   * @param id - The relationship type ID.
+   */
+  deleteType(id) {
+    return this.http.delete(`/ontology/relationships/relationship-types/${id}`);
+  }
+  /**
+   * Lists relationship instances with pagination.
+   * @param opts - Pagination options.
+   */
+  async list(opts = {}) {
+    const raw = await this.http.get(
+      "/ontology/relationships/relationships",
+      opts
+    );
+    return createPageResult(
+      asPagePayload(raw),
+      (c) => this.list({ ...opts, cursor: c })
+    );
+  }
+  /**
+   * Fetches a relationship instance by ID.
+   * @param id - The relationship ID.
+   */
+  get(id) {
+    return this.http.get(`/ontology/relationships/relationships/${id}`);
+  }
+  /**
+   * Creates or updates a relationship instance.
+   * @param id - The relationship ID.
+   * @param body - The relationship data.
+   */
+  put(id, body) {
+    return this.http.put(`/ontology/relationships/relationships/${id}`, body);
+  }
+  /**
+   * Deletes a relationship instance.
+   * @param id - The relationship ID.
+   */
+  delete(id) {
+    return this.http.delete(`/ontology/relationships/relationships/${id}`);
+  }
+};
+var SchemasNamespace = class extends SubdomainBase {
+  constructor(http) {
+    super(http, "/ontology/schemas");
+  }
+  /**
+   * Lists schema definitions with pagination.
+   * @param opts - Pagination options.
+   */
+  async list(opts = {}) {
+    const raw = await this.http.get("/ontology/schemas/schemas", opts);
+    return createPageResult(
+      asPagePayload(raw),
+      (c) => this.list({ ...opts, cursor: c })
+    );
+  }
+  /**
+   * Creates a new schema definition.
+   * @param body - The schema definition.
+   */
+  create(body) {
+    return this.http.post("/ontology/schemas/schemas", body);
+  }
+  /**
+   * Validates a schema definition.
+   * @param body - The schema to validate.
+   */
+  validate(body) {
+    return this.http.post("/ontology/schemas/schemas/validate", body);
+  }
+  /**
+   * Fetches a schema definition by ID.
+   * @param id - The schema ID.
+   */
+  get(id) {
+    return this.http.get(`/ontology/schemas/schemas/${id}`);
+  }
+  /**
+   * Deletes a schema definition.
+   * @param id - The schema ID.
+   */
+  delete(id) {
+    return this.http.delete(`/ontology/schemas/schemas/${id}`);
+  }
+};
+var VersionsNamespace = class extends SubdomainBase {
+  constructor(http) {
+    super(http, "/ontology/versions");
+  }
+  /**
+   * Creates a new version.
+   * @param body - Version creation payload.
+   */
+  create(body) {
+    return this.http.post("/ontology/versions/versions", body);
+  }
+  /**
+   * Compares two versions.
+   * @param body - Comparison parameters.
+   */
+  compare(body) {
+    return this.http.post("/ontology/versions/versions/compare", body);
+  }
+  /**
+   * Fetches a version by ID.
+   * @param id - The version ID.
+   */
+  get(id) {
+    return this.http.get(`/ontology/versions/versions/${id}`);
+  }
+  /**
+   * Deletes a version.
+   * @param id - The version ID.
+   */
+  delete(id) {
+    return this.http.delete(`/ontology/versions/versions/${id}`);
+  }
+  /**
+   * Verifies an audit trail for a version.
+   * @param body - Audit verification payload.
+   */
+  auditVerify(body) {
+    return this.http.post("/ontology/versions/audit/verify", body);
+  }
+  /**
+   * Lists release bundles with pagination.
+   * @param opts - Pagination options.
+   */
+  async listReleaseBundles(opts = {}) {
+    const raw = await this.http.get("/ontology/versions/release-bundles", opts);
+    return createPageResult(
+      asPagePayload(raw),
+      (c) => this.listReleaseBundles({ ...opts, cursor: c })
+    );
+  }
+  /**
+   * Creates a new release bundle.
+   * @param body - Release bundle payload.
+   */
+  createReleaseBundle(body) {
+    return this.http.post("/ontology/versions/release-bundles", body);
+  }
+  /**
+   * Fetches a release bundle by ID.
+   * @param id - The release bundle ID.
+   */
+  getReleaseBundle(id) {
+    return this.http.get(`/ontology/versions/release-bundles/${id}`);
+  }
+};
+var ValidationNamespace = class extends SubdomainBase {
+  constructor(http) {
+    super(http, "/ontology/validation");
+  }
+  /**
+   * Validates a payload against a schema.
+   * @param body - The payload to validate.
+   */
+  validatePayload(body) {
+    return this.http.post("/ontology/validation/payloads/validate", body);
+  }
+  /**
+   * Lists validation rules with pagination.
+   * @param opts - Pagination options.
+   */
+  async listRules(opts = {}) {
+    const raw = await this.http.get("/ontology/validation/rules", opts);
+    return createPageResult(
+      asPagePayload(raw),
+      (c) => this.listRules({ ...opts, cursor: c })
+    );
+  }
+  /**
+   * Creates a validation rule.
+   * @param body - The rule definition.
+   */
+  createRule(body) {
+    return this.http.post("/ontology/validation/rules", body);
+  }
+  /**
+   * Fetches a validation rule by ID.
+   * @param id - The rule ID.
+   */
+  getRule(id) {
+    return this.http.get(`/ontology/validation/rules/${id}`);
+  }
+  /**
+   * Deletes a validation rule.
+   * @param id - The rule ID.
+   */
+  deleteRule(id) {
+    return this.http.delete(`/ontology/validation/rules/${id}`);
+  }
+};
+var TransformationsNamespace = class extends SubdomainBase {
+  constructor(http) {
+    super(http, "/ontology/transformations");
+  }
+  /**
+   * Creates a data transformation.
+   * @param body - The transformation definition.
+   */
+  create(body) {
+    return this.http.post("/ontology/transformations/transformations", body);
+  }
+};
+var ReasoningNamespace = class extends SubdomainBase {
+  constructor(http) {
+    super(http, "/ontology/reasoning");
+  }
+  /**
+   * Generates an explanation for a reasoning result.
+   * @param body - Explanation request.
+   */
+  explain(body) {
+    return this.http.post("/ontology/reasoning/explain", body);
+  }
+  /**
+   * Retrieves facts based on criteria.
+   * @param body - Fact query parameters.
+   */
+  facts(body) {
+    return this.http.post("/ontology/reasoning/facts", body);
+  }
+  /**
+   * Loads facts into the reasoning graph.
+   * @param body - Facts graph data.
+   */
+  loadFactsGraph(body) {
+    return this.http.post("/ontology/reasoning/facts/load-graph", body);
+  }
+  /**
+   * Performs forward chaining reasoning.
+   * @param body - Forward reasoning parameters.
+   */
+  reasonForward(body) {
+    return this.http.post("/ontology/reasoning/reason/forward", body);
+  }
+  /**
+   * Performs backward chaining reasoning.
+   * @param body - Backward reasoning parameters.
+   */
+  reasonBackward(body) {
+    return this.http.post("/ontology/reasoning/reason/backward", body);
+  }
+  /**
+   * Lists reasoning rules with pagination.
+   * @param opts - Pagination options.
+   */
+  async listRules(opts = {}) {
+    const raw = await this.http.get("/ontology/reasoning/rules", opts);
+    return createPageResult(
+      asPagePayload(raw),
+      (c) => this.listRules({ ...opts, cursor: c })
+    );
+  }
+  /**
+   * Creates a reasoning rule.
+   * @param body - The rule definition.
+   */
+  createRule(body) {
+    return this.http.post("/ontology/reasoning/rules", body);
+  }
+  /**
+   * Updates a reasoning rule.
+   * @param id - The rule ID.
+   * @param body - The updated rule fields.
+   */
+  updateRule(id, body) {
+    return this.http.put(`/ontology/reasoning/rules/${id}`, body);
+  }
+  /**
+   * Deletes a reasoning rule.
+   * @param id - The rule ID.
+   */
+  deleteRule(id) {
+    return this.http.delete(`/ontology/reasoning/rules/${id}`);
+  }
+};
+var RolloutsNamespace = class extends SubdomainBase {
+  constructor(http) {
+    super(http, "/ontology/rollouts");
+  }
+  /**
+   * Lists rollouts with pagination.
+   * @param opts - Pagination options.
+   */
+  async list(opts = {}) {
+    const raw = await this.http.get("/ontology/rollouts/rollouts", opts);
+    return createPageResult(
+      asPagePayload(raw),
+      (c) => this.list({ ...opts, cursor: c })
+    );
+  }
+  /**
+   * Creates a new rollout.
+   * @param body - Rollout configuration.
+   */
+  create(body) {
+    return this.http.post("/ontology/rollouts/rollouts", body);
+  }
+  /**
+   * Fetches a rollout by ID.
+   * @param id - The rollout ID.
+   */
+  get(id) {
+    return this.http.get(`/ontology/rollouts/rollouts/${id}`);
+  }
+  /**
+   * Updates a rollout.
+   * @param id - The rollout ID.
+   * @param body - The updated rollout fields.
+   */
+  update(id, body) {
+    return this.http.put(`/ontology/rollouts/rollouts/${id}`, body);
+  }
+  /**
+   * Deletes a rollout.
+   * @param id - The rollout ID.
+   */
+  delete(id) {
+    return this.http.delete(`/ontology/rollouts/rollouts/${id}`);
+  }
+  /**
+   * Starts a rollout.
+   * @param id - The rollout ID.
+   * @param body - Start parameters.
+   */
+  start(id, body = {}) {
+    return this.http.post(`/ontology/rollouts/rollouts/${id}/start`, body);
+  }
+  /**
+   * Pauses a rollout.
+   * @param id - The rollout ID.
+   * @param body - Pause parameters.
+   */
+  pause(id, body = {}) {
+    return this.http.post(`/ontology/rollouts/rollouts/${id}/pause`, body);
+  }
+  /**
+   * Resumes a paused rollout.
+   * @param id - The rollout ID.
+   * @param body - Resume parameters.
+   */
+  resume(id, body = {}) {
+    return this.http.post(`/ontology/rollouts/rollouts/${id}/resume`, body);
+  }
+  /**
+   * Rolls back a rollout.
+   * @param id - The rollout ID.
+   * @param body - Rollback parameters.
+   */
+  rollback(id, body = {}) {
+    return this.http.post(`/ontology/rollouts/rollouts/${id}/rollback`, body);
+  }
+  /**
+   * Returns the current status of a rollout.
+   * @param id - The rollout ID.
+   */
+  status(id) {
+    return this.http.get(`/ontology/rollouts/rollouts/${id}/status`);
+  }
+};
+var RollupsNamespace = class extends SubdomainBase {
+  constructor(http) {
+    super(http, "/ontology/rollups");
+  }
+  /**
+   * Lists rollups with pagination.
+   * @param opts - Pagination options.
+   */
+  async list(opts = {}) {
+    const raw = await this.http.get("/ontology/rollups/rollups", opts);
+    return createPageResult(
+      asPagePayload(raw),
+      (c) => this.list({ ...opts, cursor: c })
+    );
+  }
+  /**
+   * Creates a rollup job.
+   * @param body - Rollup configuration.
+   */
+  create(body) {
+    return this.http.post("/ontology/rollups/rollups", body);
+  }
+  /**
+   * Fetches a rollup by ID.
+   * @param id - The rollup ID.
+   */
+  get(id) {
+    return this.http.get(`/ontology/rollups/rollups/${id}`);
+  }
+  /**
+   * Updates a rollup.
+   * @param id - The rollup ID.
+   * @param body - The updated rollup fields.
+   */
+  update(id, body) {
+    return this.http.put(`/ontology/rollups/rollups/${id}`, body);
+  }
+  /**
+   * Deletes a rollup.
+   * @param id - The rollup ID.
+   */
+  delete(id) {
+    return this.http.delete(`/ontology/rollups/rollups/${id}`);
+  }
+  /**
+   * Executes a rollup.
+   * @param id - The rollup ID.
+   * @param body - Execution parameters.
+   */
+  execute(id, body = {}) {
+    return this.http.post(`/ontology/rollups/rollups/${id}/execute`, body);
+  }
+  /**
+   * Previews a rollup result without persisting it.
+   * @param id - The rollup ID.
+   * @param body - Preview parameters.
+   */
+  preview(id, body = {}) {
+    return this.http.post(`/ontology/rollups/rollups/${id}/preview`, body);
+  }
+  /**
+   * Fetches the result of a rollup execution.
+   * @param id - The rollup ID.
+   */
+  result(id) {
+    return this.http.get(`/ontology/rollups/rollups/${id}/result`);
+  }
+  /**
+   * Fetches the result of a specific rollup execution.
+   * @param executionId - The execution ID.
+   */
+  executionResult(executionId) {
+    return this.http.get(`/ontology/rollups/rollup-results/${executionId}`);
+  }
+};
+var ExtractNamespace = class extends SubdomainBase {
+  constructor(http) {
+    super(http, "/ontology/extract");
+  }
+  /**
+   * Analyzes source data for extraction.
+   * @param body - Analysis parameters.
+   */
+  analyze(body) {
+    return this.http.post("/ontology/extract/extract/analyze", body);
+  }
+  /**
+   * Extracts architecture from source data.
+   * @param body - Architecture extraction parameters.
+   */
+  architecture(body) {
+    return this.http.post("/ontology/extract/extract/architecture", body);
+  }
+  /**
+   * Extracts coreference chains from source data.
+   * @param body - Coreference extraction parameters.
+   */
+  coreferences(body) {
+    return this.http.post("/ontology/extract/extract/coreferences", body);
+  }
+  /**
+   * Extracts entities from source data.
+   * @param body - Entity extraction parameters.
+   */
+  entities(body) {
+    return this.http.post("/ontology/extract/extract/entities", body);
+  }
+  /**
+   * Extracts events from source data.
+   * @param body - Event extraction parameters.
+   */
+  events(body) {
+    return this.http.post("/ontology/extract/extract/events", body);
+  }
+  /**
+   * Extracts relations from source data.
+   * @param body - Relation extraction parameters.
+   */
+  relations(body) {
+    return this.http.post("/ontology/extract/extract/relations", body);
+  }
+  /**
+   * Extracts RDF triplets from source data.
+   * @param body - Triplet extraction parameters.
+   */
+  triplets(body) {
+    return this.http.post("/ontology/extract/extract/triplets", body);
+  }
+};
+var EventsNamespace = class extends SubdomainBase {
+  constructor(http) {
+    super(http, "/ontology/events");
+  }
+  /**
+   * Lists events with pagination.
+   * @param opts - Pagination options.
+   */
+  async list(opts = {}) {
+    const raw = await this.http.get("/ontology/events/events", opts);
+    return createPageResult(
+      asPagePayload(raw),
+      (c) => this.list({ ...opts, cursor: c })
+    );
+  }
+  /**
+   * Creates a new event.
+   * @param body - The event payload.
+   */
+  create(body) {
+    return this.http.post("/ontology/events/events", body);
+  }
+  /**
+   * Fetches an event by ID.
+   * @param id - The event ID.
+   */
+  get(id) {
+    return this.http.get(`/ontology/events/events/${id}`);
+  }
+  /**
+   * Creates an event checkpoint for a consumer.
+   * @param body - Checkpoint data.
+   */
+  createCheckpoint(body) {
+    return this.http.post("/ontology/events/events/checkpoints", body);
+  }
+  /**
+   * Fetches the checkpoint for a consumer.
+   * @param consumer - The consumer identifier.
+   */
+  getCheckpoint(consumer) {
+    return this.http.get(`/ontology/events/events/checkpoints/${consumer}`);
+  }
+  /**
+   * Acquires a lease for event processing.
+   * @param body - Lease acquisition parameters.
+   */
+  acquireLease(body) {
+    return this.http.post("/ontology/events/events/leases/acquire", body);
+  }
+  /**
+   * Acknowledges a lease after processing.
+   * @param body - Lease acknowledgment parameters.
+   */
+  acknowledgeLease(body) {
+    return this.http.post("/ontology/events/events/leases/acknowledge", body);
   }
 };
 
-// src/index.ts
+// src/client.ts
 function createOntologyClient(clientOrConfig) {
-  var _a, _b, _c, _d, _e;
   if (clientOrConfig instanceof FrontalClient) {
-    return new OntologyService(clientOrConfig._http);
+    return new OntologySdk(clientOrConfig.httpClient);
   }
   const http = new HttpClient({
     apiKey: clientOrConfig.apiKey,
-    baseUrl: (_c = (_b = (_a = clientOrConfig.baseUrl) != null ? _a : process.env.FRONTAL_ONTOLOGY_API_URL) != null ? _b : process.env.FRONTAL_API_URL) != null ? _c : "https://api.frontal.dev/v1",
-    timeout: (_d = clientOrConfig.timeout) != null ? _d : 3e4,
-    maxRetries: (_e = clientOrConfig.maxRetries) != null ? _e : 3,
-    retryDelay: 1e3,
+    baseUrl: clientOrConfig.baseUrl ?? env.FRONTAL_API_URL ?? DEFAULT_ONTOLOGY_BASE_URL,
+    timeout: clientOrConfig.timeout ?? DEFAULT_TIMEOUT,
+    maxRetries: clientOrConfig.maxRetries ?? DEFAULT_MAX_RETRIES,
+    retryDelay: DEFAULT_RETRY_DELAY,
     headers: {},
-    environment: "production",
-    debug: false
+    environment: env.FRONTAL_ENV,
+    debug: env.FRONTAL_DEBUG ?? false
   });
-  return new OntologyService(http);
+  return new OntologySdk(http);
 }
-var ontology = new OntologyService(getDefaultClient()._http);
+var _ontologyCache;
+var ontology = new Proxy({}, {
+  get(_t, prop) {
+    if (!_ontologyCache) {
+      _ontologyCache = createOntologyClient(getDefaultClient());
+    }
+    const inst = _ontologyCache;
+    const val = inst[prop];
+    return typeof val === "function" ? val.bind(inst) : val;
+  }
+});
+
+// src/schemas.ts
+import { z as z5 } from "zod";
+var FieldTypeSchema = z5.enum([
+  "string",
+  "integer",
+  "float",
+  "boolean",
+  "uuid",
+  "timestamp",
+  "currency",
+  "json",
+  "array",
+  "enum",
+  "vector",
+  "text"
+]);
+var RelationshipTypeSchema = z5.enum([
+  "hasOne",
+  "hasMany",
+  "belongsTo",
+  "manyToMany"
+]);
+var FieldDefinitionSchema = z5.object({
+  type: FieldTypeSchema,
+  required: z5.boolean().default(false),
+  primary: z5.boolean().default(false),
+  unique: z5.boolean().default(false),
+  default: z5.unknown().optional(),
+  substrate: z5.string().optional(),
+  computed: z5.boolean().optional(),
+  derivedBy: z5.string().optional(),
+  cache: z5.object({
+    ttl: z5.string()
+  }).optional(),
+  auto: z5.boolean().optional(),
+  enum: z5.array(z5.string()).optional(),
+  dimensions: z5.number().int().optional(),
+  items: z5.string().optional(),
+  description: z5.string().optional()
+}).loose();
+var RelationshipDefinitionSchema = z5.object({
+  name: z5.string().optional(),
+  type: RelationshipTypeSchema,
+  targetEntity: z5.string(),
+  foreignKey: z5.string().optional(),
+  substrate: z5.string().optional(),
+  cascade: z5.object({
+    delete: z5.enum(["hard", "soft", "restrict", "nullify"]),
+    update: z5.enum(["cascade", "restrict"])
+  }).optional(),
+  computed: z5.record(z5.string(), z5.unknown()).optional(),
+  description: z5.string().optional()
+}).loose();
+var SubstrateRoutingSchema = z5.object({
+  operational: z5.string().optional(),
+  analytical: z5.string().optional(),
+  semantic: z5.string().optional(),
+  cache: z5.string().optional()
+}).loose();
+var SemanticMetadataSchema = z5.object({
+  description: z5.string().optional(),
+  lifecycle: z5.array(z5.string()).optional(),
+  criticalFields: z5.array(z5.string()).optional(),
+  significantEvents: z5.array(z5.string()).optional(),
+  tags: z5.array(z5.string()).optional()
+}).loose();
+var IndexDefinitionSchema = z5.object({
+  name: z5.string().optional(),
+  fields: z5.array(z5.string()).min(1),
+  substrate: z5.string().optional(),
+  unique: z5.boolean().default(false),
+  type: z5.enum(["btree", "hash", "gin", "gist", "brin"]).default("btree")
+}).loose();
+var ModelDefinitionSchema = z5.object({
+  name: z5.string(),
+  displayName: z5.string().optional(),
+  description: z5.string().optional(),
+  extends: z5.string().optional(),
+  mixins: z5.array(z5.string()).optional(),
+  fields: z5.record(z5.string(), FieldDefinitionSchema),
+  relationships: z5.record(z5.string(), RelationshipDefinitionSchema).optional(),
+  substrates: SubstrateRoutingSchema.optional(),
+  semantics: SemanticMetadataSchema.optional(),
+  indexes: z5.array(IndexDefinitionSchema).optional(),
+  status: z5.enum(["draft", "active", "deprecated"]).default("draft")
+}).strict();
+var ModelSchema = ModelDefinitionSchema.extend({
+  id: z5.string(),
+  version: z5.number().int(),
+  createdAt: timestampSchema,
+  updatedAt: timestampSchema,
+  entityCount: z5.number().int().optional()
+}).loose();
+var MigrationPlanSchema = z5.object({
+  id: z5.string(),
+  modelId: z5.string(),
+  fromVersion: z5.number().int(),
+  toVersion: z5.number().int(),
+  changes: z5.array(
+    z5.object({
+      type: z5.enum([
+        "add-field",
+        "remove-field",
+        "modify-field",
+        "add-relationship",
+        "remove-relationship"
+      ]),
+      description: z5.string(),
+      impact: z5.enum(["breaking", "non-breaking", "data-loss"]),
+      sql: z5.string().optional()
+    })
+  ),
+  riskLevel: z5.enum(["low", "medium", "high", "critical"]),
+  estimatedDowntime: z5.string().optional(),
+  rolloutStrategy: z5.enum([
+    "zero-downtime",
+    "maintenance-window",
+    "immediate"
+  ]),
+  createdAt: timestampSchema
+}).loose();
+var RuleDefinitionSchema = z5.object({
+  name: z5.string(),
+  description: z5.string().optional(),
+  entityTypes: z5.array(z5.string()).min(1),
+  condition: z5.string(),
+  action: z5.enum(["validate", "transform", "notify"]),
+  severity: z5.enum(["error", "warning", "info"]),
+  enabled: z5.boolean().default(true)
+}).strict();
+var MixinDefinitionSchema = z5.object({
+  name: z5.string(),
+  description: z5.string().optional(),
+  fields: z5.record(z5.string(), FieldDefinitionSchema),
+  relationships: z5.record(z5.string(), RelationshipDefinitionSchema).optional(),
+  appliesTo: z5.array(z5.string()).optional()
+}).strict();
 export {
+  DEFAULT_ONTOLOGY_BASE_URL,
   FieldDefinitionSchema,
   FieldTypeSchema,
   IndexDefinitionSchema,
@@ -423,12 +2085,13 @@ export {
   MixinDefinitionSchema,
   ModelDefinitionSchema,
   ModelSchema,
-  OntologyService,
+  OntologySdk,
   RelationshipDefinitionSchema,
   RelationshipTypeSchema,
   RuleDefinitionSchema,
   SemanticMetadataSchema,
   SubstrateRoutingSchema,
+  VERSION,
   createOntologyClient,
   ontology
 };