@kinotic-ai/os-api 1.0.0-beta.0 → 1.0.0-beta.2

package/README.md

@@ -0,0 +1,64 @@
+# @kinotic-ai/os-api
+
+The high-level TypeScript API for managing everything in your Kinotic cloud OS. `@kinotic-ai/os-api` puts the full power of the platform in your hands — create applications, define data schemas, run migrations, manage queries, and monitor your system, all from code. It is the control plane for teams that want to automate and programmatically manage their Kinotic environment end to end.
+
+**[Get started at kinotic.ai/getting-started](https://kinotic.ai/getting-started)**
+
+> **Who is this for?** `@kinotic-ai/os-api` is intended for teams **building or extending Kinotic OS itself** — platform engineers managing the control plane, provisioning tooling, or internal infrastructure. If you are building an application *on top of* Kinotic OS, you most likely want [`@kinotic-ai/persistence`](https://www.npmjs.com/package/@kinotic-ai/persistence) and [`@kinotic-ai/core`](https://www.npmjs.com/package/@kinotic-ai/core) instead.
+
+---
+
+## Why @kinotic-ai/os-api?
+
+- **Manage your whole cloud OS from code.** Applications, projects, schemas, migrations, and analytics are all first-class operations — no console required.
+- **Ship data APIs in seconds.** Publish a schema at runtime and the platform creates storage, REST endpoints, and a GraphQL schema automatically.
+- **Migrations as code.** Run and track schema migrations programmatically, not through ad-hoc scripts or manual steps.
+- **One line to activate.** Plugs directly into your existing Kinotic connection — no additional setup, no separate configuration.
+- **Full observability built in.** Structured logging and built-in analytics give you visibility into your applications without extra tooling.
+
+---
+
+## Features
+
+### Application and Project Management
+Create, configure, and manage cloud applications and projects programmatically. Automate provisioning as part of your deployment pipeline rather than through manual console operations.
+
+### Runtime Schema Publishing
+Define and publish new data schemas at runtime. The moment a schema is published, the platform creates the backing storage, generates REST API endpoints, and builds the corresponding GraphQL schema — all automatically.
+
+### Schema Migrations
+Run and track schema migrations from your application code. Migration state is managed by the platform, so you always know what has been applied and what is pending.
+
+### Named Query Management
+Define, publish, and manage reusable parameterized queries across your platform. Queries are platform-level resources — shared, versioned, and callable by any service.
+
+### Analytics and Data Insights
+Built-in analytics give you operational visibility into your applications and data without instrumenting your own pipeline. Query usage, data trends, and system health are available directly through the API.
+
+### Structured Application Logging
+Emit structured, searchable logs from the client side using the same logging infrastructure the platform uses. No separate log aggregation setup required.
+
+---
+
+## Part of the Kinotic Ecosystem
+
+`@kinotic-ai/os-api` sits at the top of the Kinotic JavaScript/TypeScript stack:
+
+```
+@kinotic-ai/os-api      ← cloud OS management (this package)
+@kinotic-ai/persistence ← schema-driven data access
+@kinotic-ai/idl         ← cross-language type schemas
+@kinotic-ai/core        ← connection & transport
+```
+
+It builds on the full stack below it. Install `@kinotic-ai/core` for the connection, add `@kinotic-ai/idl` and `@kinotic-ai/persistence` for data access, and use `@kinotic-ai/os-api` when you need to manage the platform itself.
+
+---
+
+## Installation
+
+```bash
+npm install @kinotic-ai/os-api
+```
+
+For full documentation, guides, and API reference, visit **[kinotic.ai](https://kinotic.ai)**.

package/dist/index.cjs

@@ -0,0 +1,607 @@
+var import_node_module = require("node:module");
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toCommonJS = (from) => {
+  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+        });
+  }
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __moduleCache;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+
+// packages/os-api/src/index.ts
+var exports_src = {};
+__export(exports_src, {
+  VersionDecorator: () => VersionDecorator,
+  TypescriptProjectConfig: () => TypescriptProjectConfig,
+  TypescriptExternalProjectConfig: () => TypescriptExternalProjectConfig,
+  TransformConfiguration: () => TransformConfiguration,
+  TimeReferenceDecorator: () => TimeReferenceDecorator,
+  TextDecorator: () => TextDecorator,
+  TenantSelectionC3Type: () => TenantSelectionC3Type,
+  TenantIdDecorator: () => TenantIdDecorator,
+  StructuresProjectConfig: () => StructuresProjectConfig,
+  SingleLoggerLevelsDescriptor: () => SingleLoggerLevelsDescriptor,
+  RoleDecorator: () => RoleDecorator,
+  QueryOptionsC3Type: () => QueryOptionsC3Type,
+  QueryDecorator: () => QueryDecorator,
+  ProjectType: () => ProjectType,
+  ProjectService: () => ProjectService,
+  Project: () => Project,
+  ProgressType: () => ProgressType,
+  PolicyDecorator: () => PolicyDecorator,
+  PageableC3Type: () => PageableC3Type,
+  PageC3Type: () => PageC3Type,
+  OverrideConfiguration: () => OverrideConfiguration,
+  OsApiPlugin: () => OsApiPlugin,
+  NotIndexedDecorator: () => NotIndexedDecorator,
+  NestedDecorator: () => NestedDecorator,
+  NamedQueriesService: () => NamedQueriesService,
+  NamedQueriesDefinition: () => NamedQueriesDefinition,
+  MigrationService: () => MigrationService,
+  LoggersDescriptor: () => LoggersDescriptor,
+  LoggerLevelsDescriptor: () => LoggerLevelsDescriptor,
+  LogManager: () => LogManager,
+  LogLevel: () => LogLevel,
+  IdDecorator: () => IdDecorator,
+  GroupLoggerLevelsDescriptor: () => GroupLoggerLevelsDescriptor,
+  FlattenedDecorator: () => FlattenedDecorator,
+  EsIndexConfigurationDecorator: () => EsIndexConfigurationDecorator,
+  EntityDefinitionService: () => EntityDefinitionService,
+  EntityDefinition: () => EntityDefinition,
+  EntityDecorator: () => EntityDecorator,
+  EntityConfiguration: () => EntityConfiguration,
+  DiscriminatorDecorator: () => DiscriminatorDecorator,
+  DataInsightsService: () => DataInsightsService,
+  CalculatedPropertyConfiguration: () => CalculatedPropertyConfiguration,
+  AutoGeneratedIdDecorator: () => AutoGeneratedIdDecorator,
+  ApplicationService: () => ApplicationService,
+  Application: () => Application,
+  $Role: () => $Role,
+  $Policy: () => $Policy
+});
+module.exports = __toCommonJS(exports_src);
+
+// packages/os-api/src/api/model/idl/decorators/AutoGeneratedIdDecorator.ts
+var import_idl = require("@kinotic-ai/idl");
+
+class AutoGeneratedIdDecorator extends import_idl.C3Decorator {
+  constructor() {
+    super();
+    this.type = "AutoGeneratedId";
+  }
+}
+// packages/os-api/src/api/model/idl/decorators/DiscriminatorDecorator.ts
+var import_idl2 = require("@kinotic-ai/idl");
+
+class DiscriminatorDecorator extends import_idl2.C3Decorator {
+  propertyName;
+  constructor() {
+    super();
+    this.type = "Discriminator";
+  }
+  withPropertyName(propertyName) {
+    this.propertyName = propertyName;
+    return this;
+  }
+}
+// packages/os-api/src/api/model/idl/decorators/EntityDecorator.ts
+var import_persistence = require("@kinotic-ai/persistence");
+var import_idl3 = require("@kinotic-ai/idl");
+
+class EntityDecorator extends import_idl3.C3Decorator {
+  multiTenancyType = import_persistence.MultiTenancyType.NONE;
+  entityType = import_persistence.EntityType.TABLE;
+  constructor() {
+    super();
+    this.type = "Entity";
+  }
+  withMultiTenancyType(type) {
+    this.multiTenancyType = type;
+    return this;
+  }
+  withEntityType(type) {
+    this.entityType = type;
+    return this;
+  }
+}
+// packages/os-api/src/api/model/idl/decorators/EsIndexConfigurationDecorator.ts
+var import_idl4 = require("@kinotic-ai/idl");
+
+class EsIndexConfigurationDecorator extends import_idl4.C3Decorator {
+  value;
+  constructor() {
+    super();
+    this.type = "EsIndexConfigurationDecorator";
+  }
+}
+// packages/os-api/src/api/model/idl/decorators/FlattenedDecorator.ts
+var import_idl5 = require("@kinotic-ai/idl");
+
+class FlattenedDecorator extends import_idl5.C3Decorator {
+  constructor() {
+    super();
+    this.type = "Flattened";
+  }
+}
+// packages/os-api/src/api/model/idl/decorators/IdDecorator.ts
+var import_idl6 = require("@kinotic-ai/idl");
+
+class IdDecorator extends import_idl6.C3Decorator {
+  constructor() {
+    super();
+    this.type = "Id";
+  }
+}
+// packages/os-api/src/api/model/idl/decorators/NestedDecorator.ts
+var import_idl7 = require("@kinotic-ai/idl");
+
+class NestedDecorator extends import_idl7.C3Decorator {
+  constructor() {
+    super();
+    this.type = "Nested";
+  }
+}
+// packages/os-api/src/api/model/idl/decorators/NotIndexedDecorator.ts
+var import_idl8 = require("@kinotic-ai/idl");
+
+class NotIndexedDecorator extends import_idl8.C3Decorator {
+  constructor() {
+    super();
+    this.type = "NotIndexedDecorator";
+  }
+}
+// packages/os-api/src/api/model/idl/decorators/PolicyDecorator.ts
+var import_persistence2 = require("@kinotic-ai/persistence");
+
+class PolicyDecorator extends import_persistence2.EntityServiceDecorator {
+  policies;
+  constructor(policies) {
+    super();
+    this.type = "PolicyDecorator";
+    this.policies = policies;
+  }
+}
+function $Policy(policies) {
+  return new PolicyDecorator(policies);
+}
+// packages/os-api/src/api/model/idl/decorators/QueryDecorator.ts
+var import_idl9 = require("@kinotic-ai/idl");
+
+class QueryDecorator extends import_idl9.C3Decorator {
+  statements;
+  constructor(statements) {
+    super();
+    this.type = "Query";
+    this.statements = statements;
+  }
+}
+// packages/os-api/src/api/model/idl/decorators/RoleDecorator.ts
+var import_persistence3 = require("@kinotic-ai/persistence");
+
+class RoleDecorator extends import_persistence3.EntityServiceDecorator {
+  roles;
+  constructor(roles) {
+    super();
+    this.type = "RoleDecorator";
+    this.roles = roles;
+  }
+}
+function $Role(roles) {
+  return new RoleDecorator(roles);
+}
+// packages/os-api/src/api/model/idl/decorators/TenantIdDecorator.ts
+var import_idl10 = require("@kinotic-ai/idl");
+
+class TenantIdDecorator extends import_idl10.C3Decorator {
+  constructor() {
+    super();
+    this.type = "TenantIdDecorator";
+  }
+}
+// packages/os-api/src/api/model/idl/decorators/TextDecorator.ts
+var import_idl11 = require("@kinotic-ai/idl");
+
+class TextDecorator extends import_idl11.C3Decorator {
+  constructor() {
+    super();
+    this.type = "Text";
+  }
+}
+// packages/os-api/src/api/model/idl/decorators/TimeReferenceDecorator.ts
+var import_idl12 = require("@kinotic-ai/idl");
+
+class TimeReferenceDecorator extends import_idl12.C3Decorator {
+  constructor() {
+    super();
+    this.type = "TimeReferenceDecorator";
+  }
+}
+// packages/os-api/src/api/model/idl/decorators/VersionDecorator.ts
+var import_idl13 = require("@kinotic-ai/idl");
+
+class VersionDecorator extends import_idl13.C3Decorator {
+  constructor() {
+    super();
+    this.type = "VersionDecorator";
+  }
+}
+// packages/os-api/src/api/model/idl/PageC3Type.ts
+var import_idl14 = require("@kinotic-ai/idl");
+
+class PageC3Type extends import_idl14.C3Type {
+  contentType;
+  constructor(contentType) {
+    super("page");
+    this.contentType = contentType;
+  }
+}
+// packages/os-api/src/api/model/idl/PageableC3Type.ts
+var import_idl15 = require("@kinotic-ai/idl");
+
+class PageableC3Type extends import_idl15.C3Type {
+  constructor() {
+    super("pageable");
+  }
+}
+// packages/os-api/src/api/model/idl/QueryOptionsC3Type.ts
+var import_idl16 = require("@kinotic-ai/idl");
+
+class QueryOptionsC3Type extends import_idl16.ObjectC3Type {
+  type = "queryOptions";
+  constructor() {
+    super("QueryOptions", "org.kinotic.structures.domain");
+    this.addProperty("timeZone", new import_idl16.StringC3Type);
+    this.addProperty("requestTimeout", new import_idl16.IntC3Type);
+    this.addProperty("pageTimeout", new import_idl16.StringC3Type);
+  }
+}
+// packages/os-api/src/api/model/idl/TenantSelectionC3Type.ts
+var import_idl17 = require("@kinotic-ai/idl");
+
+class TenantSelectionC3Type extends import_idl17.ArrayC3Type {
+  type = "tenantSelection";
+  constructor() {
+    super(new import_idl17.StringC3Type);
+  }
+}
+// packages/os-api/src/api/model/Application.ts
+class Application {
+  id;
+  description;
+  updated = null;
+  enableGraphQL = false;
+  enableOpenAPI = false;
+  constructor(id, description) {
+    this.id = id;
+    this.description = description;
+  }
+}
+// packages/os-api/src/api/model/Project.ts
+class Project {
+  id = null;
+  applicationId;
+  name;
+  description;
+  sourceOfTruth = null;
+  updated = null;
+  constructor(id, applicationId, name, description) {
+    this.id = id;
+    this.applicationId = applicationId;
+    this.name = name;
+    this.description = description;
+  }
+}
+// packages/os-api/src/api/model/ProjectType.ts
+var ProjectType;
+((ProjectType2) => {
+  ProjectType2[ProjectType2["TYPESCRIPT"] = 0] = "TYPESCRIPT";
+  ProjectType2[ProjectType2["GRAPHQL"] = 1] = "GRAPHQL";
+  ProjectType2[ProjectType2["GRAPHICAL"] = 2] = "GRAPHICAL";
+  ProjectType2[ProjectType2["ELASTICSEARCH"] = 3] = "ELASTICSEARCH";
+})(ProjectType ||= {});
+// packages/os-api/src/api/model/EntityDefinition.ts
+class EntityDefinition {
+  id;
+  applicationId;
+  projectId;
+  name;
+  entityDefinition;
+  description;
+  created;
+  updated;
+  published;
+  publishedTimestamp;
+  constructor(applicationId, projectId, name, entityDefinition, description) {
+    this.applicationId = applicationId;
+    this.projectId = projectId;
+    this.name = name;
+    this.entityDefinition = entityDefinition;
+    this.description = description;
+  }
+}
+// packages/os-api/src/api/model/NamedQueriesDefinition.ts
+class NamedQueriesDefinition {
+  id;
+  applicationId;
+  projectId;
+  structure;
+  namedQueries;
+  constructor(id, applicationId, projectId, structure, namedQueries) {
+    this.id = id;
+    this.applicationId = applicationId;
+    this.projectId = projectId;
+    this.structure = structure;
+    this.namedQueries = namedQueries;
+  }
+}
+// packages/os-api/src/api/model/config/CalculatedPropertyConfiguration.ts
+class CalculatedPropertyConfiguration {
+  entityJsonPath;
+  propertyName;
+  calculatedPropertyFunctionName;
+  decorators;
+}
+// packages/os-api/src/api/model/config/EntityConfiguration.ts
+class EntityConfiguration {
+  entityName;
+  multiTenancyType;
+  excludeJsonPaths;
+  overrides;
+  transforms;
+  calculatedProperties;
+}
+// packages/os-api/src/api/model/config/OverrideConfiguration.ts
+class OverrideConfiguration {
+  jsonPath;
+  propertyDefinition;
+}
+// packages/os-api/src/api/model/config/StructuresProjectConfig.ts
+class StructuresProjectConfig {
+  mdl;
+  name;
+  description;
+  application;
+  entitiesPaths;
+  generatedPath;
+  fileExtensionForImports = ".js";
+  validate;
+}
+
+class TypescriptProjectConfig extends StructuresProjectConfig {
+  mdl = "ts";
+}
+
+class TypescriptExternalProjectConfig extends StructuresProjectConfig {
+  mdl = "ts-external";
+  externalEntities;
+  utilFunctionsPaths;
+}
+// packages/os-api/src/api/model/config/TransformConfiguration.ts
+class TransformConfiguration {
+  jsonPath;
+  transformerFunctionName;
+}
+// packages/os-api/src/api/model/insights/InsightProgress.ts
+var ProgressType;
+((ProgressType2) => {
+  ProgressType2["STARTED"] = "STARTED";
+  ProgressType2["ANALYZING"] = "ANALYZING";
+  ProgressType2["DISCOVERING_DATA"] = "DISCOVERING_DATA";
+  ProgressType2["GENERATING_CODE"] = "GENERATING_CODE";
+  ProgressType2["COMPONENTS_READY"] = "COMPONENTS_READY";
+  ProgressType2["COMPLETED"] = "COMPLETED";
+  ProgressType2["ERROR"] = "ERROR";
+})(ProgressType ||= {});
+// packages/os-api/src/api/services/IApplicationService.ts
+var import_core = require("@kinotic-ai/core");
+
+class ApplicationService extends import_core.CrudServiceProxy {
+  constructor(kinotic) {
+    super(kinotic.serviceProxy("org.kinotic.structures.api.services.ApplicationService"));
+  }
+  createApplicationIfNotExist(id, description) {
+    return this.serviceProxy.invoke("createApplicationIfNotExist", [id, description]);
+  }
+  syncIndex() {
+    return this.serviceProxy.invoke("syncIndex", []);
+  }
+}
+// packages/os-api/src/api/services/ILogManager.ts
+var LogLevel;
+((LogLevel2) => {
+  LogLevel2["TRACE"] = "TRACE";
+  LogLevel2["DEBUG"] = "DEBUG";
+  LogLevel2["INFO"] = "INFO";
+  LogLevel2["WARN"] = "WARN";
+  LogLevel2["ERROR"] = "ERROR";
+  LogLevel2["FATAL"] = "FATAL";
+  LogLevel2["OFF"] = "OFF";
+})(LogLevel ||= {});
+
+class LoggerLevelsDescriptor {
+  configuredLevel;
+}
+
+class GroupLoggerLevelsDescriptor extends LoggerLevelsDescriptor {
+  members = [];
+}
+
+class SingleLoggerLevelsDescriptor extends LoggerLevelsDescriptor {
+  effectiveLevel;
+}
+
+class LoggersDescriptor {
+  levels = [];
+  loggerLevels = new Map;
+  groups = new Map;
+}
+// packages/os-api/src/api/services/IProjectService.ts
+var import_core2 = require("@kinotic-ai/core");
+
+class ProjectService extends import_core2.CrudServiceProxy {
+  constructor(kinotic) {
+    super(kinotic.serviceProxy("org.kinotic.structures.api.services.ProjectService"));
+  }
+  countForApplication(applicationId) {
+    return this.serviceProxy.invoke("countForApplication", [applicationId]);
+  }
+  createProjectIfNotExist(project) {
+    return this.serviceProxy.invoke("createProjectIfNotExist", [project]);
+  }
+  async findAllForApplication(applicationId, pageable) {
+    const page = await this.findAllForApplicationSinglePage(applicationId, pageable);
+    return new import_core2.FunctionalIterablePage(pageable, page, (pageable2) => this.findAllForApplicationSinglePage(applicationId, pageable2));
+  }
+  findAllForApplicationSinglePage(applicationId, pageable) {
+    return this.serviceProxy.invoke("findAllForApplication", [applicationId, pageable]);
+  }
+  syncIndex() {
+    return this.serviceProxy.invoke("syncIndex", []);
+  }
+}
+// packages/os-api/src/api/services/LogManager.ts
+class LogManager {
+  serviceProxy;
+  constructor(kinotic) {
+    this.serviceProxy = kinotic.serviceProxy("org.kinotic.os.api.services.LogManager");
+  }
+  loggers(nodeId) {
+    return this.serviceProxy.invoke("loggers", null, nodeId);
+  }
+  async loggerLevels(nodeId, name) {
+    const data = await this.serviceProxy.invoke("loggerLevels", [name], nodeId);
+    let ret = null;
+    if (data.hasOwnProperty("members")) {
+      ret = new GroupLoggerLevelsDescriptor;
+    } else if (data.hasOwnProperty("effectiveLevel")) {
+      ret = new SingleLoggerLevelsDescriptor;
+    } else {
+      ret = new LoggerLevelsDescriptor;
+    }
+    Object.assign(ret, data);
+    return ret;
+  }
+  configureLogLevel(nodeId, name, level) {
+    return this.serviceProxy.invoke("configureLogLevel", [name, level], nodeId);
+  }
+}
+// packages/os-api/src/api/services/IEntityDefinitionService.ts
+var import_core3 = require("@kinotic-ai/core");
+
+class EntityDefinitionService extends import_core3.CrudServiceProxy {
+  constructor(kinotic) {
+    super(kinotic.serviceProxy("org.kinotic.persistence.api.services.EntityDefinitionService"));
+  }
+  countForApplication(applicationId) {
+    return this.serviceProxy.invoke("countForApplication", [applicationId]);
+  }
+  countForProject(projectId) {
+    return this.serviceProxy.invoke("countForProject", [projectId]);
+  }
+  findAllForApplicationSinglePage(applicationId, pageable) {
+    return this.serviceProxy.invoke("findAllForApplication", [applicationId, pageable]);
+  }
+  async findAllForApplication(applicationId, pageable) {
+    const page = await this.findAllForApplicationSinglePage(applicationId, pageable);
+    return new import_core3.FunctionalIterablePage(pageable, page, (pageable2) => this.findAllForApplicationSinglePage(applicationId, pageable2));
+  }
+  findAllPublishedForApplication(applicationId, pageable) {
+    return this.serviceProxy.invoke("findAllPublishedForApplication", [applicationId, pageable]);
+  }
+  async findAllForProject(projectId, pageable) {
+    const page = await this.findAllForProjectSinglePage(projectId, pageable);
+    return new import_core3.FunctionalIterablePage(pageable, page, (pageable2) => this.findAllForProjectSinglePage(projectId, pageable2));
+  }
+  findAllForProjectSinglePage(projectId, pageable) {
+    return this.serviceProxy.invoke("findAllForProject", [projectId, pageable]);
+  }
+  publish(entityDefinitionId) {
+    return this.serviceProxy.invoke("publish", [entityDefinitionId]);
+  }
+  unPublish(entityDefinitionId) {
+    return this.serviceProxy.invoke("unPublish", [entityDefinitionId]);
+  }
+  syncIndex() {
+    return this.serviceProxy.invoke("syncIndex", []);
+  }
+}
+// packages/os-api/src/api/services/INamedQueriesService.ts
+var import_core4 = require("@kinotic-ai/core");
+
+class NamedQueriesService extends import_core4.CrudServiceProxy {
+  constructor(kinotic) {
+    super(kinotic.serviceProxy("org.kinotic.persistence.api.services.NamedQueriesService"));
+  }
+  syncIndex() {
+    return this.serviceProxy.invoke("syncIndex", []);
+  }
+}
+// packages/os-api/src/api/services/IMigrationService.ts
+class MigrationService {
+  serviceProxy;
+  constructor(kinotic) {
+    this.serviceProxy = kinotic.serviceProxy("org.kinotic.persistence.api.services.MigrationService");
+  }
+  executeMigrations(migrationRequest) {
+    return this.serviceProxy.invoke("executeMigrations", [migrationRequest]);
+  }
+  getLastAppliedMigrationVersion(projectId) {
+    return this.serviceProxy.invoke("getLastAppliedMigrationVersion", [projectId]);
+  }
+  isMigrationApplied(projectId, version) {
+    return this.serviceProxy.invoke("isMigrationApplied", [projectId, version]);
+  }
+}
+// packages/os-api/src/api/services/IDataInsightsService.ts
+class DataInsightsService {
+  serviceProxy;
+  constructor(kinotic) {
+    this.serviceProxy = kinotic.serviceProxy("org.kinotic.persistence.api.services.insights.DataInsightsService");
+  }
+  processRequest(request) {
+    return this.serviceProxy.invokeStream("processRequest", [request]);
+  }
+}
+// packages/os-api/src/api/OsApiPlugin.ts
+var OsApiPlugin = {
+  install(kinotic) {
+    return {
+      applications: new ApplicationService(kinotic),
+      projects: new ProjectService(kinotic),
+      logManager: new LogManager(kinotic),
+      entityDefinitions: new EntityDefinitionService(kinotic),
+      namedQueries: new NamedQueriesService(kinotic),
+      migrations: new MigrationService(kinotic),
+      dataInsights: new DataInsightsService(kinotic)
+    };
+  }
+};