@frontal-labs/ontology 0.0.1 → 1.0.0

package/dist/index.js

@@ -1,25 +1,8 @@
 "use strict";
 var __defProp = Object.defineProperty;
-var __defProps = Object.defineProperties;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-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 __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -33,30 +16,11 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-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());
-  });
-};
 
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  DEFAULT_ONTOLOGY_BASE_URL: () => DEFAULT_ONTOLOGY_BASE_URL,
   FieldDefinitionSchema: () => FieldDefinitionSchema,
   FieldTypeSchema: () => FieldTypeSchema,
   IndexDefinitionSchema: () => IndexDefinitionSchema,
@@ -64,23 +28,845 @@ __export(index_exports, {
   MixinDefinitionSchema: () => MixinDefinitionSchema,
   ModelDefinitionSchema: () => ModelDefinitionSchema,
   ModelSchema: () => ModelSchema,
-  OntologyService: () => OntologyService,
+  OntologySdk: () => OntologySdk,
   RelationshipDefinitionSchema: () => RelationshipDefinitionSchema,
   RelationshipTypeSchema: () => RelationshipTypeSchema,
   RuleDefinitionSchema: () => RuleDefinitionSchema,
   SemanticMetadataSchema: () => SemanticMetadataSchema,
   SubstrateRoutingSchema: () => SubstrateRoutingSchema,
+  VERSION: () => VERSION,
   createOntologyClient: () => createOntologyClient,
   ontology: () => ontology
 });
 module.exports = __toCommonJS(index_exports);
-var import_core3 = require("@frontal-labs/core");
 
-// src/service.ts
+// src/client.ts
 var import_core2 = require("@frontal-labs/core");
 
-// src/schemas.ts
+// 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 import_core = require("@frontal-labs/core");
+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;
+  }
+  /**
+   * Returns the capabilities of this subdomain service.
+   */
+  capabilities() {
+    return this.http.get(`${this.base}/capabilities`);
+  }
+  /**
+   * Health check for this subdomain service.
+   */
+  health() {
+    return this.http.get(`${this.base}/health`);
+  }
+  /**
+   * Returns service info/metadata for this subdomain service.
+   */
+  info() {
+    return this.http.get(`${this.base}/info`);
+  }
+  /**
+   * Lists asynchronous runs for this subdomain.
+   * @param opts - Pagination options.
+   */
+  async runs(opts = {}) {
+    const raw = await this.http.get(`${this.base}/runs`, opts);
+    return (0, import_core.createPageResult)(
+      (0, import_core.asPagePayload)(raw),
+      (c) => this.runs({ ...opts, cursor: c })
+    );
+  }
+  /**
+   * 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 EngineNamespace = class extends SubdomainBase {
+  constructor(http) {
+    super(http, "/ontology/engine");
+  }
+  /**
+   * Generates an ontology from a description.
+   * @param input - Generation parameters.
+   */
+  generate(input) {
+    return this.http.post("/ontology/engine/ontologies/generate", input);
+  }
+  /**
+   * 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 ObjectsNamespace = class extends SubdomainBase {
+  constructor(http) {
+    super(http, "/ontology/objects");
+  }
+  /**
+   * Lists object types with pagination.
+   * @param opts - Pagination options.
+   */
+  async listObjectTypes(opts = {}) {
+    const raw = await this.http.get("/ontology/objects/object-types", opts);
+    return (0, import_core.createPageResult)(
+      (0, import_core.asPagePayload)(raw),
+      (c) => this.listObjectTypes({ ...opts, cursor: c })
+    );
+  }
+  /**
+   * Fetches an object type by ID.
+   * @param id - The object type ID.
+   */
+  getObjectType(id) {
+    return this.http.get(`/ontology/objects/object-types/${id}`);
+  }
+  /**
+   * 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);
+  }
+  /**
+   * Deletes an object type.
+   * @param id - The object type ID.
+   */
+  deleteObjectType(id) {
+    return this.http.delete(`/ontology/objects/object-types/${id}`);
+  }
+  /**
+   * Lists object instances with pagination.
+   * @param opts - Pagination options.
+   */
+  async listObjects(opts = {}) {
+    const raw = await this.http.get("/ontology/objects/objects", opts);
+    return (0, import_core.createPageResult)(
+      (0, import_core.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 (0, import_core.createPageResult)(
+      (0, import_core.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 (0, import_core.createPageResult)(
+      (0, import_core.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 (0, import_core.createPageResult)(
+      (0, import_core.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 (0, import_core.createPageResult)(
+      (0, import_core.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 (0, import_core.createPageResult)(
+      (0, import_core.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 (0, import_core.createPageResult)(
+      (0, import_core.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 (0, import_core.createPageResult)(
+      (0, import_core.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 (0, import_core.createPageResult)(
+      (0, import_core.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 (0, import_core.createPageResult)(
+      (0, import_core.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/client.ts
+var import_core3 = require("@frontal-labs/core");
+function createOntologyClient(clientOrConfig) {
+  if (clientOrConfig instanceof import_core2.FrontalClient) {
+    return new OntologySdk(clientOrConfig.httpClient);
+  }
+  const http = new import_core2.HttpClient({
+    apiKey: clientOrConfig.apiKey,
+    baseUrl: clientOrConfig.baseUrl ?? import_core3.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: import_core3.env.FRONTAL_ENV,
+    debug: import_core3.env.FRONTAL_DEBUG ?? false
+  });
+  return new OntologySdk(http);
+}
+var _ontologyCache;
+var ontology = new Proxy({}, {
+  get(_t, prop) {
+    if (!_ontologyCache) {
+      _ontologyCache = createOntologyClient((0, import_core2.getDefaultClient)());
+    }
+    const inst = _ontologyCache;
+    const val = inst[prop];
+    return typeof val === "function" ? val.bind(inst) : val;
+  }
+});
+
+// src/schemas.ts
+var import_core4 = require("@frontal-labs/core");
 var import_zod = require("zod");
 var FieldTypeSchema = import_zod.z.enum([
   "string",
@@ -119,7 +905,7 @@ var FieldDefinitionSchema = import_zod.z.object({
   dimensions: import_zod.z.number().int().optional(),
   items: import_zod.z.string().optional(),
   description: import_zod.z.string().optional()
-}).passthrough();
+}).loose();
 var RelationshipDefinitionSchema = import_zod.z.object({
   name: import_zod.z.string().optional(),
   type: RelationshipTypeSchema,
@@ -132,27 +918,27 @@ var RelationshipDefinitionSchema = import_zod.z.object({
   }).optional(),
   computed: import_zod.z.record(import_zod.z.string(), import_zod.z.unknown()).optional(),
   description: import_zod.z.string().optional()
-}).passthrough();
+}).loose();
 var SubstrateRoutingSchema = import_zod.z.object({
   operational: import_zod.z.string().optional(),
   analytical: import_zod.z.string().optional(),
   semantic: import_zod.z.string().optional(),
   cache: import_zod.z.string().optional()
-}).passthrough();
+}).loose();
 var SemanticMetadataSchema = import_zod.z.object({
   description: import_zod.z.string().optional(),
   lifecycle: import_zod.z.array(import_zod.z.string()).optional(),
   criticalFields: import_zod.z.array(import_zod.z.string()).optional(),
   significantEvents: import_zod.z.array(import_zod.z.string()).optional(),
   tags: import_zod.z.array(import_zod.z.string()).optional()
-}).passthrough();
+}).loose();
 var IndexDefinitionSchema = import_zod.z.object({
   name: import_zod.z.string().optional(),
   fields: import_zod.z.array(import_zod.z.string()).min(1),
   substrate: import_zod.z.string().optional(),
   unique: import_zod.z.boolean().default(false),
   type: import_zod.z.enum(["btree", "hash", "gin", "gist", "brin"]).default("btree")
-}).passthrough();
+}).loose();
 var ModelDefinitionSchema = import_zod.z.object({
   name: import_zod.z.string(),
   displayName: import_zod.z.string().optional(),
@@ -169,10 +955,10 @@ var ModelDefinitionSchema = import_zod.z.object({
 var ModelSchema = ModelDefinitionSchema.extend({
   id: import_zod.z.string(),
   version: import_zod.z.number().int(),
-  createdAt: import_core.timestampSchema,
-  updatedAt: import_core.timestampSchema,
+  createdAt: import_core4.timestampSchema,
+  updatedAt: import_core4.timestampSchema,
   entityCount: import_zod.z.number().int().optional()
-}).passthrough();
+}).loose();
 var MigrationPlanSchema = import_zod.z.object({
   id: import_zod.z.string(),
   modelId: import_zod.z.string(),
@@ -199,8 +985,8 @@ var MigrationPlanSchema = import_zod.z.object({
     "maintenance-window",
     "immediate"
   ]),
-  createdAt: import_core.timestampSchema
-}).passthrough();
+  createdAt: import_core4.timestampSchema
+}).loose();
 var RuleDefinitionSchema = import_zod.z.object({
   name: import_zod.z.string(),
   description: import_zod.z.string().optional(),
@@ -217,239 +1003,9 @@ var MixinDefinitionSchema = import_zod.z.object({
   relationships: import_zod.z.record(import_zod.z.string(), RelationshipDefinitionSchema).optional(),
   appliesTo: import_zod.z.array(import_zod.z.string()).optional()
 }).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 (0, import_core2.createPageResult)(
-        asPagePayload(raw),
-        (cursor) => this.list(__spreadProps(__spreadValues({}, opts), { cursor }))
-      );
-    });
-  }
-  create(definition) {
-    return __async(this, null, function* () {
-      const body = ModelDefinitionSchema.parse(definition);
-      return this.http.post("/ontology/engine/runs", body);
-    });
-  }
-  validate(definition) {
-    return __async(this, null, function* () {
-      const body = ModelDefinitionSchema.parse(definition);
-      return this.http.post("/ontology/engine/ontologies/validate", body);
-    });
-  }
-  checkIntegrity() {
-    return __async(this, null, function* () {
-      return this.http.get("/ontology/engine/health");
-    });
-  }
-};
-var ModelAccessor = class {
-  constructor(_name, http) {
-    this._name = _name;
-    this.http = http;
-  }
-  get(version) {
-    return __async(this, null, function* () {
-      const params = version ? { version } : void 0;
-      return this.http.get("/ontology/engine/runs", params);
-    });
-  }
-  update(definition) {
-    return __async(this, null, function* () {
-      return this.http.post("/ontology/engine/runs", definition);
-    });
-  }
-  delete(force = false) {
-    return __async(this, null, function* () {
-      return this.http.post("/ontology/engine/runs", {
-        action: "delete-model",
-        force
-      });
-    });
-  }
-  relationships() {
-    return __async(this, null, function* () {
-      return this.http.get("/ontology/engine/runs");
-    });
-  }
-  addRelationship(definition) {
-    return __async(this, null, function* () {
-      const body = RelationshipDefinitionSchema.parse(definition);
-      return this.http.post("/ontology/engine/runs", body);
-    });
-  }
-  removeRelationship(relationshipId) {
-    return __async(this, null, function* () {
-      return this.http.post("/ontology/engine/runs", {
-        action: "delete-relationship",
-        relationshipId
-      });
-    });
-  }
-  validateData() {
-    return __async(this, null, function* () {
-      return this.http.post("/ontology/engine/ontologies/validate");
-    });
-  }
-  versions() {
-    return __async(this, null, function* () {
-      return this.http.get("/ontology/engine/runs");
-    });
-  }
-};
-var MigrationsNamespace = class {
-  constructor(http) {
-    this.http = http;
-  }
-  plan(request) {
-    return __async(this, null, function* () {
-      return this.http.post(
-        "/ontology/engine/ontologies/compare-versions",
-        request
-      );
-    });
-  }
-  apply(planId, strategy = "zero-downtime") {
-    return __async(this, null, function* () {
-      return this.http.post("/ontology/engine/runs", { planId, strategy });
-    });
-  }
-  rollback(_migrationId) {
-    return __async(this, null, function* () {
-      return this.http.post("/ontology/engine/runs");
-    });
-  }
-  history() {
-    return __async(this, arguments, function* (opts = {}) {
-      const raw = yield this.http.get("/ontology/engine/runs", opts);
-      return (0, import_core2.createPageResult)(
-        asPagePayload(raw),
-        (cursor) => this.history(__spreadProps(__spreadValues({}, opts), { cursor }))
-      );
-    });
-  }
-};
-var RulesNamespace = class {
-  constructor(http) {
-    this.http = http;
-  }
-  list() {
-    return __async(this, null, function* () {
-      return this.http.get("/ontology/engine/runs");
-    });
-  }
-  create(definition) {
-    return __async(this, null, function* () {
-      const body = RuleDefinitionSchema.parse(definition);
-      return this.http.post("/ontology/engine/runs", body);
-    });
-  }
-  update(_ruleId, definition) {
-    return __async(this, null, function* () {
-      return this.http.post("/ontology/engine/runs", definition);
-    });
-  }
-  delete(ruleId) {
-    return __async(this, null, function* () {
-      return this.http.post("/ontology/engine/runs", {
-        action: "delete-rule",
-        ruleId
-      });
-    });
-  }
-  evaluate(opts) {
-    return __async(this, null, function* () {
-      return this.http.post("/ontology/engine/ontologies/validate", opts);
-    });
-  }
-};
-var MixinsNamespace = class {
-  constructor(http) {
-    this.http = http;
-  }
-  list() {
-    return __async(this, null, function* () {
-      return this.http.get("/ontology/engine/runs");
-    });
-  }
-  create(definition) {
-    return __async(this, null, function* () {
-      const body = MixinDefinitionSchema.parse(definition);
-      return this.http.post("/ontology/engine/runs", body);
-    });
-  }
-};
-var GenerationNamespace = class {
-  constructor(http) {
-    this.http = http;
-  }
-  generate(description, opts) {
-    return __async(this, null, function* () {
-      return this.http.post("/ontology/engine/ontologies/generate", __spreadValues({
-        description
-      }, opts));
-    });
-  }
-  infer(opts) {
-    return __async(this, null, function* () {
-      return this.http.post("/ontology/engine/ontologies/infer-classes", opts);
-    });
-  }
-  suggestions() {
-    return __async(this, arguments, function* (opts = {}) {
-      return this.http.get("/ontology/engine/runs", opts);
-    });
-  }
-  acceptSuggestion(_suggestionId) {
-    return __async(this, null, function* () {
-      return this.http.post("/ontology/engine/runs");
-    });
-  }
-  rejectSuggestion(_suggestionId, reason) {
-    return __async(this, null, function* () {
-      return this.http.post("/ontology/engine/runs", {
-        reason
-      });
-    });
-  }
-};
-
-// src/index.ts
-function createOntologyClient(clientOrConfig) {
-  var _a, _b, _c, _d, _e;
-  if (clientOrConfig instanceof import_core3.FrontalClient) {
-    return new OntologyService(clientOrConfig._http);
-  }
-  const http = new import_core3.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,
-    headers: {},
-    environment: "production",
-    debug: false
-  });
-  return new OntologyService(http);
-}
-var ontology = new OntologyService((0, import_core3.getDefaultClient)()._http);
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  DEFAULT_ONTOLOGY_BASE_URL,
   FieldDefinitionSchema,
   FieldTypeSchema,
   IndexDefinitionSchema,
@@ -457,12 +1013,13 @@ var ontology = new OntologyService((0, import_core3.getDefaultClient)()._http);
   MixinDefinitionSchema,
   ModelDefinitionSchema,
   ModelSchema,
-  OntologyService,
+  OntologySdk,
   RelationshipDefinitionSchema,
   RelationshipTypeSchema,
   RuleDefinitionSchema,
   SemanticMetadataSchema,
   SubstrateRoutingSchema,
+  VERSION,
   createOntologyClient,
   ontology
 });