@lssm/lib.contracts 0.0.0-canary-20251217052941 → 0.0.0-canary-20251217060433

package/dist/app-config/validation.d.ts

@@ -0,0 +1,47 @@
+import { CapabilityRegistry } from "../capabilities.js";
+import { DataViewRegistry } from "../data-views.js";
+import { WorkflowRegistry } from "../workflow/spec.js";
+import { IntegrationSpecRegistry } from "../integrations/spec.js";
+import { IntegrationConnection } from "../integrations/connection.js";
+import { KnowledgeSpaceRegistry } from "../knowledge/spec.js";
+import { KnowledgeSourceConfig } from "../knowledge/source.js";
+import { BlueprintTranslationCatalog, PlatformTranslationCatalog } from "../translations/catalog.js";
+import { AppBlueprintSpec, TenantAppConfig } from "./spec.js";
+import { ResolvedAppConfig } from "./runtime.js";
+
+//#region src/app-config/validation.d.ts
+type ValidationSeverity = 'error' | 'warning' | 'info';
+interface ValidationIssue {
+  code: string;
+  severity: ValidationSeverity;
+  path: string;
+  message: string;
+  suggestion?: string;
+  docsUrl?: string;
+}
+interface ValidationResult {
+  valid: boolean;
+  errors: ValidationIssue[];
+  warnings: ValidationIssue[];
+  info: ValidationIssue[];
+}
+interface ValidationContext {
+  integrationSpecs?: IntegrationSpecRegistry;
+  knowledgeSpaces?: KnowledgeSpaceRegistry;
+  knowledgeSources?: KnowledgeSourceConfig[];
+  capabilities?: CapabilityRegistry;
+  dataViews?: DataViewRegistry;
+  workflows?: WorkflowRegistry;
+  tenantConnections?: IntegrationConnection[];
+  existingConfigs?: TenantAppConfig[];
+  translationCatalogs?: {
+    platform?: PlatformTranslationCatalog | PlatformTranslationCatalog[] | undefined;
+    blueprint?: BlueprintTranslationCatalog | BlueprintTranslationCatalog[] | undefined;
+  };
+}
+declare function validateConfig(blueprint: AppBlueprintSpec, tenant: TenantAppConfig, context?: ValidationContext): ValidationResult;
+declare function validateBlueprint(blueprint: AppBlueprintSpec, context?: ValidationContext): ValidationResult;
+declare function validateTenantConfig(blueprint: AppBlueprintSpec, tenant: TenantAppConfig, context?: ValidationContext): ValidationResult;
+declare function validateResolvedConfig(blueprint: AppBlueprintSpec, resolved: ResolvedAppConfig, context?: ValidationContext): ValidationResult;
+//#endregion
+export { ValidationContext, ValidationIssue, ValidationResult, ValidationSeverity, validateBlueprint, validateConfig, validateResolvedConfig, validateTenantConfig };

package/dist/capabilities/docs/capabilities.docblock.d.ts

@@ -0,0 +1,6 @@
+import { DocBlock } from "@lssm/lib.contracts/docs";
+
+//#region src/capabilities/docs/capabilities.docblock.d.ts
+declare const tech_contracts_capabilities_DocBlocks: DocBlock[];
+//#endregion
+export { tech_contracts_capabilities_DocBlocks };

package/dist/capabilities/openbanking.d.ts

@@ -0,0 +1,9 @@
+import { CapabilityRegistry, CapabilitySpec } from "../capabilities.js";
+
+//#region src/capabilities/openbanking.d.ts
+declare const openBankingAccountsReadCapability: CapabilitySpec;
+declare const openBankingTransactionsReadCapability: CapabilitySpec;
+declare const openBankingBalancesReadCapability: CapabilitySpec;
+declare function registerOpenBankingCapabilities(registry: CapabilityRegistry): CapabilityRegistry;
+//#endregion
+export { openBankingAccountsReadCapability, openBankingBalancesReadCapability, openBankingTransactionsReadCapability, registerOpenBankingCapabilities };

package/dist/capabilities.d.ts

@@ -0,0 +1,48 @@
+import { OwnerShipMeta } from "./ownership.js";
+import { DocId } from "./docs/registry.js";
+
+//#region src/capabilities.d.ts
+type CapabilityKind = 'api' | 'event' | 'data' | 'ui' | 'integration';
+type CapabilitySurface = 'operation' | 'event' | 'workflow' | 'presentation' | 'resource';
+interface CapabilitySurfaceRef {
+  surface: CapabilitySurface;
+  name: string;
+  version: number;
+  description?: string;
+}
+interface CapabilityMeta extends OwnerShipMeta {
+  /** Stable capability slug (e.g., "payments.stripe"). */
+  key: string;
+  /** Increment when the capability shape changes. */
+  version: number;
+  kind: CapabilityKind;
+  /** Optional doc block id for governance and navigation. */
+  docId?: DocId;
+}
+interface CapabilityRequirement {
+  key: string;
+  version?: number;
+  kind?: CapabilityKind;
+  optional?: boolean;
+  reason?: string;
+}
+interface CapabilityRef {
+  key: string;
+  version: number;
+}
+interface CapabilitySpec {
+  meta: CapabilityMeta;
+  provides?: CapabilitySurfaceRef[];
+  requires?: CapabilityRequirement[];
+}
+declare class CapabilityRegistry {
+  private readonly items;
+  register(spec: CapabilitySpec): this;
+  list(): CapabilitySpec[];
+  get(key: string, version?: number): CapabilitySpec | undefined;
+  satisfies(requirement: CapabilityRequirement, additional?: CapabilityRef[] | undefined): boolean;
+}
+declare function capabilityKey(spec: CapabilitySpec): string;
+declare function defineCapability(spec: CapabilitySpec): CapabilitySpec;
+//#endregion
+export { CapabilityKind, CapabilityMeta, CapabilityRef, CapabilityRegistry, CapabilityRequirement, CapabilitySpec, CapabilitySurface, CapabilitySurfaceRef, capabilityKey, defineCapability };

package/dist/client/index.d.ts

@@ -0,0 +1,6 @@
+import { createEngineWithDefaults, createFeatureModule, registerFeature, renderFeaturePresentation } from "./react/feature-render.js";
+import { ComputationMap, CreateRendererOptions, DriverSlots, RenderOptions, ResolverMap, createFormRenderer } from "./react/form-render.js";
+import { ShadcnDriver, shadcnDriver } from "./react/drivers/shadcn.js";
+import { RnReusablesDriver, rnReusablesDriver } from "./react/drivers/rn-reusables.js";
+import "./react/index.js";
+export { ComputationMap, CreateRendererOptions, DriverSlots, RenderOptions, ResolverMap, RnReusablesDriver, ShadcnDriver, createEngineWithDefaults, createFeatureModule, createFormRenderer, registerFeature, renderFeaturePresentation, rnReusablesDriver, shadcnDriver };

package/dist/client/react/drivers/rn-reusables.d.ts

@@ -0,0 +1,22 @@
+import { DriverSlots } from "../form-render.js";
+
+//#region src/client/react/drivers/rn-reusables.d.ts
+
+/**
+ * Create a React Native UI-kit driver by mapping required slots to components.
+ * Host apps should import their UI-kit primitives and pass them here.
+ *
+ * Example usage:
+ * ```tsx
+ * import { rnReusablesDriver } from '@lssm/lib.contracts/client/react/drivers/rn-reusables';
+ * import { Input, Textarea, Button } from '@lssm/lib.ui-kit/ui';
+ *
+ * const driver = rnReusablesDriver({
+ *   Input, Textarea, Button, // ... other components
+ * });
+ * ```
+ */
+declare function rnReusablesDriver(slots: DriverSlots): DriverSlots;
+type RnReusablesDriver = ReturnType<typeof rnReusablesDriver>;
+//#endregion
+export { RnReusablesDriver, rnReusablesDriver };

package/dist/client/react/drivers/shadcn.d.ts

@@ -0,0 +1,12 @@
+import { DriverSlots } from "../form-render.js";
+
+//#region src/client/react/drivers/shadcn.d.ts
+
+/**
+ * Create a shadcn/ui driver by mapping required slots to components.
+ * Host apps should import their shadcn primitives and pass them here.
+ */
+declare function shadcnDriver(slots: DriverSlots): DriverSlots;
+type ShadcnDriver = ReturnType<typeof shadcnDriver>;
+//#endregion
+export { ShadcnDriver, shadcnDriver };

package/dist/client/react/feature-render.d.ts

@@ -0,0 +1,19 @@
+import { ComponentMap, PresentationDescriptorV2, PresentationTarget, TransformEngine } from "../../presentations.v2.js";
+import { FeatureModuleSpec, FeatureRegistry } from "../../features.js";
+import React from "react";
+import { BlockConfig } from "@blocknote/core";
+
+//#region src/client/react/feature-render.d.ts
+declare function createEngineWithDefaults(): TransformEngine;
+declare function renderFeaturePresentation(engine: TransformEngine, target: PresentationTarget, desc: PresentationDescriptorV2, options?: {
+  componentMap?: ComponentMap;
+  reactProps?: Record<string, unknown>;
+  renderBlockNote?: (docJson: unknown, blockConfig?: BlockConfig) => React.ReactElement;
+}): Promise<React.ReactElement | {
+  mimeType: string;
+  body: string;
+} | null>;
+declare function createFeatureModule(meta: FeatureModuleSpec['meta'], refs: Partial<Pick<FeatureModuleSpec, 'operations' | 'events' | 'presentations' | 'presentationsTargets'>>): FeatureModuleSpec;
+declare function registerFeature(registry: FeatureRegistry, feature: FeatureModuleSpec): FeatureRegistry;
+//#endregion
+export { createEngineWithDefaults, createFeatureModule, registerFeature, renderFeaturePresentation };

package/dist/client/react/form-render.d.ts

@@ -0,0 +1,91 @@
+import { FormOption, FormSpec, FormValuesFor } from "../../forms.js";
+import { AnySchemaModel } from "@lssm/lib.schema";
+import React from "react";
+import * as react_jsx_runtime0 from "react/jsx-runtime";
+
+//#region src/client/react/form-render.d.ts
+interface DriverSlots {
+  Field: React.ComponentType<React.PropsWithChildren<{
+    'data-invalid'?: boolean;
+    hidden?: boolean;
+    disabled?: boolean;
+  }>>;
+  FieldLabel: React.ComponentType<React.PropsWithChildren<{
+    htmlFor?: string;
+  }>>;
+  FieldDescription: React.ComponentType<React.PropsWithChildren<{}>>;
+  FieldError: React.ComponentType<{
+    errors: {
+      message?: string;
+    }[];
+  }>;
+  FieldGroup?: React.ComponentType<React.PropsWithChildren<{
+    className?: string;
+  }>>;
+  FieldSet?: React.ComponentType<React.PropsWithChildren<{
+    className?: string;
+  }>>;
+  FieldLegend?: React.ComponentType<React.PropsWithChildren<{
+    variant?: 'label' | 'default';
+  }>>;
+  Input: React.ComponentType<React.InputHTMLAttributes<HTMLInputElement>>;
+  Textarea: React.ComponentType<React.TextareaHTMLAttributes<HTMLTextAreaElement>>;
+  Select: React.ComponentType<{
+    id?: string;
+    name?: string;
+    value?: unknown;
+    onChange?: (v: any) => void;
+    disabled?: boolean;
+    'aria-invalid'?: boolean;
+    options: FormOption[];
+  } & Record<string, unknown>>;
+  Checkbox: React.ComponentType<{
+    id?: string;
+    name?: string;
+    checked?: boolean;
+    onCheckedChange?: (v: boolean) => void;
+    disabled?: boolean;
+  } & Record<string, unknown>>;
+  RadioGroup: React.ComponentType<{
+    id?: string;
+    name?: string;
+    value?: unknown;
+    onValueChange?: (v: any) => void;
+    disabled?: boolean;
+    options: FormOption[];
+  } & Record<string, unknown>>;
+  Switch: React.ComponentType<{
+    id?: string;
+    name?: string;
+    checked?: boolean;
+    onCheckedChange?: (v: boolean) => void;
+    disabled?: boolean;
+  } & Record<string, unknown>>;
+  Button: React.ComponentType<React.PropsWithChildren<{
+    type?: 'button' | 'submit' | 'reset';
+    variant?: string;
+    size?: string;
+    onClick?: () => void;
+    disabled?: boolean;
+  }>>;
+}
+type ResolverMap<TValues> = Record<string, (values: TValues, args?: any) => Promise<FormOption[]> | FormOption[]>;
+type ComputationMap<TValues> = Record<string, (values: TValues) => any>;
+interface CreateRendererOptions<TValues = any> {
+  driver: DriverSlots;
+  formOptions?: Record<string, unknown>;
+  onSubmitOverride?: (values: TValues, actionKey: string) => Promise<void> | void;
+  activeFlags?: string[];
+  resolvers?: ResolverMap<TValues>;
+  computations?: ComputationMap<TValues>;
+  unmountStrategy?: 'keep' | 'clear';
+}
+interface RenderOptions<TValues = any> {
+  defaultValues?: Partial<TValues>;
+  overrides?: Partial<CreateRendererOptions<TValues>>;
+}
+declare function createFormRenderer<M extends AnySchemaModel = AnySchemaModel>(base: CreateRendererOptions<FormValuesFor<M>>): {
+  render: (spec: FormSpec<M>, options?: RenderOptions<FormValuesFor<M>>) => react_jsx_runtime0.JSX.Element;
+};
+//#endregion
+export { ComputationMap, CreateRendererOptions, DriverSlots, RenderOptions, ResolverMap, createFormRenderer };

package/dist/client/react/index.d.ts

@@ -0,0 +1,5 @@
+import { createEngineWithDefaults, createFeatureModule, registerFeature, renderFeaturePresentation } from "./feature-render.js";
+import { ComputationMap, CreateRendererOptions, DriverSlots, RenderOptions, ResolverMap, createFormRenderer } from "./form-render.js";
+import { ShadcnDriver, shadcnDriver } from "./drivers/shadcn.js";
+import { RnReusablesDriver, rnReusablesDriver } from "./drivers/rn-reusables.js";
+export { ComputationMap, CreateRendererOptions, DriverSlots, RenderOptions, ResolverMap, RnReusablesDriver, ShadcnDriver, createEngineWithDefaults, createFeatureModule, createFormRenderer, registerFeature, renderFeaturePresentation, rnReusablesDriver, shadcnDriver };

package/dist/contract-registry/index.d.ts

@@ -0,0 +1,3 @@
+import { ContractRegistryFile, ContractRegistryItem, ContractRegistryItemType, ContractRegistryManifest, JsonSchema } from "./types.js";
+import { ContractRegistryFileSchema, ContractRegistryItemParsed, ContractRegistryItemSchema, ContractRegistryItemTypeSchema, ContractRegistryManifestParsed, ContractRegistryManifestSchema } from "./schemas.js";
+export { type ContractRegistryFile, ContractRegistryFileSchema, type ContractRegistryItem, type ContractRegistryItemParsed, ContractRegistryItemSchema, type ContractRegistryItemType, ContractRegistryItemTypeSchema, type ContractRegistryManifest, type ContractRegistryManifestParsed, ContractRegistryManifestSchema, type JsonSchema };

package/dist/contract-registry/schemas.d.ts

@@ -0,0 +1,124 @@
+import { ContractRegistryItem, ContractRegistryManifest } from "./types.js";
+import z from "zod";
+
+//#region src/contract-registry/schemas.d.ts
+declare const ContractRegistryItemTypeSchema: z.ZodEnum<{
+  "contractspec:operation": "contractspec:operation";
+  "contractspec:event": "contractspec:event";
+  "contractspec:presentation": "contractspec:presentation";
+  "contractspec:form": "contractspec:form";
+  "contractspec:feature": "contractspec:feature";
+  "contractspec:workflow": "contractspec:workflow";
+  "contractspec:template": "contractspec:template";
+  "contractspec:integration": "contractspec:integration";
+  "contractspec:data-view": "contractspec:data-view";
+  "contractspec:migration": "contractspec:migration";
+  "contractspec:telemetry": "contractspec:telemetry";
+  "contractspec:experiment": "contractspec:experiment";
+  "contractspec:app-config": "contractspec:app-config";
+  "contractspec:knowledge": "contractspec:knowledge";
+}>;
+declare const ContractRegistryFileSchema: z.ZodObject<{
+  path: z.ZodString;
+  type: z.ZodString;
+  content: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+declare const ContractRegistryItemSchema: z.ZodObject<{
+  name: z.ZodString;
+  type: z.ZodEnum<{
+    "contractspec:operation": "contractspec:operation";
+    "contractspec:event": "contractspec:event";
+    "contractspec:presentation": "contractspec:presentation";
+    "contractspec:form": "contractspec:form";
+    "contractspec:feature": "contractspec:feature";
+    "contractspec:workflow": "contractspec:workflow";
+    "contractspec:template": "contractspec:template";
+    "contractspec:integration": "contractspec:integration";
+    "contractspec:data-view": "contractspec:data-view";
+    "contractspec:migration": "contractspec:migration";
+    "contractspec:telemetry": "contractspec:telemetry";
+    "contractspec:experiment": "contractspec:experiment";
+    "contractspec:app-config": "contractspec:app-config";
+    "contractspec:knowledge": "contractspec:knowledge";
+  }>;
+  version: z.ZodNumber;
+  title: z.ZodString;
+  description: z.ZodString;
+  meta: z.ZodObject<{
+    stability: z.ZodEnum<{
+      idea: "idea";
+      in_creation: "in_creation";
+      experimental: "experimental";
+      beta: "beta";
+      stable: "stable";
+      deprecated: "deprecated";
+    }>;
+    owners: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    tags: z.ZodDefault<z.ZodArray<z.ZodString>>;
+  }, z.core.$strip>;
+  dependencies: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  registryDependencies: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  files: z.ZodArray<z.ZodObject<{
+    path: z.ZodString;
+    type: z.ZodString;
+    content: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>>;
+  schema: z.ZodOptional<z.ZodObject<{
+    input: z.ZodOptional<z.ZodUnknown>;
+    output: z.ZodOptional<z.ZodUnknown>;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+declare const ContractRegistryManifestSchema: z.ZodObject<{
+  $schema: z.ZodOptional<z.ZodString>;
+  name: z.ZodString;
+  homepage: z.ZodOptional<z.ZodString>;
+  items: z.ZodArray<z.ZodObject<{
+    name: z.ZodString;
+    type: z.ZodEnum<{
+      "contractspec:operation": "contractspec:operation";
+      "contractspec:event": "contractspec:event";
+      "contractspec:presentation": "contractspec:presentation";
+      "contractspec:form": "contractspec:form";
+      "contractspec:feature": "contractspec:feature";
+      "contractspec:workflow": "contractspec:workflow";
+      "contractspec:template": "contractspec:template";
+      "contractspec:integration": "contractspec:integration";
+      "contractspec:data-view": "contractspec:data-view";
+      "contractspec:migration": "contractspec:migration";
+      "contractspec:telemetry": "contractspec:telemetry";
+      "contractspec:experiment": "contractspec:experiment";
+      "contractspec:app-config": "contractspec:app-config";
+      "contractspec:knowledge": "contractspec:knowledge";
+    }>;
+    version: z.ZodNumber;
+    title: z.ZodString;
+    description: z.ZodString;
+    meta: z.ZodObject<{
+      stability: z.ZodEnum<{
+        idea: "idea";
+        in_creation: "in_creation";
+        experimental: "experimental";
+        beta: "beta";
+        stable: "stable";
+        deprecated: "deprecated";
+      }>;
+      owners: z.ZodDefault<z.ZodArray<z.ZodString>>;
+      tags: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>;
+    dependencies: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    registryDependencies: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    files: z.ZodArray<z.ZodObject<{
+      path: z.ZodString;
+      type: z.ZodString;
+      content: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    schema: z.ZodOptional<z.ZodObject<{
+      input: z.ZodOptional<z.ZodUnknown>;
+      output: z.ZodOptional<z.ZodUnknown>;
+    }, z.core.$strip>>;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+type ContractRegistryItemParsed = z.infer<typeof ContractRegistryItemSchema> & ContractRegistryItem;
+type ContractRegistryManifestParsed = z.infer<typeof ContractRegistryManifestSchema> & ContractRegistryManifest;
+//#endregion
+export { ContractRegistryFileSchema, ContractRegistryItemParsed, ContractRegistryItemSchema, ContractRegistryItemTypeSchema, ContractRegistryManifestParsed, ContractRegistryManifestSchema };

package/dist/contract-registry/types.d.ts

@@ -0,0 +1,46 @@
+import { Owner, Stability, Tag } from "../ownership.js";
+
+//#region src/contract-registry/types.d.ts
+type ContractRegistryItemType = 'contractspec:operation' | 'contractspec:event' | 'contractspec:presentation' | 'contractspec:form' | 'contractspec:feature' | 'contractspec:workflow' | 'contractspec:template' | 'contractspec:integration' | 'contractspec:data-view' | 'contractspec:migration' | 'contractspec:telemetry' | 'contractspec:experiment' | 'contractspec:app-config' | 'contractspec:knowledge';
+type JsonSchema = unknown;
+interface ContractRegistryFile {
+  /** Path relative to the registry project root */
+  path: string;
+  /**
+   * File classification (kept open-ended to remain ejectable and compatible
+   * with multiple consumers).
+   *
+   * Examples: 'registry:component', 'contractspec:spec', 'registry:lib'
+   */
+  type: string;
+  /** Optional inline content (if serving without file hosting) */
+  content?: string;
+}
+interface ContractRegistryItem {
+  name: string;
+  type: ContractRegistryItemType;
+  version: number;
+  title: string;
+  description: string;
+  meta: {
+    stability: Stability;
+    owners: Owner[];
+    tags: Tag[];
+  };
+  dependencies?: string[];
+  registryDependencies?: string[];
+  files: ContractRegistryFile[];
+  schema?: {
+    input?: JsonSchema;
+    output?: JsonSchema;
+  };
+}
+interface ContractRegistryManifest {
+  /** Optional JSON-schema reference for tooling */
+  $schema?: string;
+  name: string;
+  homepage?: string;
+  items: ContractRegistryItem[];
+}
+//#endregion
+export { ContractRegistryFile, ContractRegistryItem, ContractRegistryItemType, ContractRegistryManifest, JsonSchema };

package/dist/contracts-adapter-hydration.d.ts

@@ -0,0 +1,15 @@
+import { ResourceRegistry } from "./resources.js";
+
+//#region src/contracts-adapter-hydration.d.ts
+interface ReturnsDecl {
+  isList: boolean;
+  inner: string;
+}
+declare function parseReturns(returnsLike: string): ReturnsDecl;
+declare function hydrateResourceIfNeeded(resources: ResourceRegistry | undefined, result: unknown, opts: {
+  template?: string;
+  varName?: string;
+  returns: ReturnsDecl;
+}): Promise<unknown>;
+//#endregion
+export { ReturnsDecl, hydrateResourceIfNeeded, parseReturns };

package/dist/contracts-adapter-input.d.ts

@@ -0,0 +1,10 @@
+import { AnySchemaModel } from "@lssm/lib.schema";
+import { SchemaTypes } from "@pothos/core";
+
+//#region src/contracts-adapter-input.d.ts
+declare function isSchemaModel(x: unknown): x is AnySchemaModel;
+declare function createInputTypeBuilder<T extends SchemaTypes>(builder: PothosSchemaTypes.SchemaBuilder<T>): {
+  buildInputFieldArgs: (model: AnySchemaModel | null) => null;
+};
+//#endregion
+export { createInputTypeBuilder, isSchemaModel };

package/dist/data-views/docs/data-views.docblock.d.ts

@@ -0,0 +1,6 @@
+import { DocBlock } from "@lssm/lib.contracts/docs";
+
+//#region src/data-views/docs/data-views.docblock.d.ts
+declare const tech_contracts_data_views_DocBlocks: DocBlock[];
+//#endregion
+export { tech_contracts_data_views_DocBlocks };

package/dist/data-views/query-generator.d.ts

@@ -0,0 +1,39 @@
+import { DataViewSpec } from "../data-views.js";
+
+//#region src/data-views/query-generator.d.ts
+interface DataViewQueryParams {
+  filters?: Record<string, any>;
+  sort?: {
+    field: string;
+    direction: 'asc' | 'desc';
+  };
+  pagination?: {
+    page: number;
+    pageSize: number;
+  };
+  search?: string;
+}
+interface DataViewQuery {
+  operationName: string;
+  input: Record<string, any>;
+  meta: {
+    pagination: {
+      page: number;
+      pageSize: number;
+      skip: number;
+      take: number;
+    };
+    sorting?: {
+      field: string;
+      direction: 'asc' | 'desc';
+    };
+  };
+}
+declare class DataViewQueryGenerator {
+  private spec;
+  constructor(spec: DataViewSpec);
+  generate(params: DataViewQueryParams): DataViewQuery;
+  validateParams(params: DataViewQueryParams): string[];
+}
+//#endregion
+export { DataViewQuery, DataViewQueryGenerator, DataViewQueryParams };

package/dist/data-views/runtime.d.ts

@@ -0,0 +1,26 @@
+import { DataViewRegistry, DataViewSpec } from "../data-views.js";
+
+//#region src/data-views/runtime.d.ts
+interface DataViewRuntimeConfig {
+  registry: DataViewRegistry;
+}
+interface DataViewResult<T = any> {
+  data: T[];
+  total: number;
+  loading: boolean;
+  error?: Error;
+}
+declare class DataViewRuntime {
+  private config;
+  private cache;
+  private subscriptions;
+  constructor(config: DataViewRuntimeConfig);
+  register(spec: DataViewSpec): void;
+  getSpec(name: string, version?: number): DataViewSpec | undefined;
+  executeQuery(specName: string, params: any): Promise<DataViewResult>;
+  invalidate(specName: string): void;
+  subscribe(specName: string, callback: () => void): () => void;
+  private notifySubscribers;
+}
+//#endregion
+export { DataViewResult, DataViewRuntime, DataViewRuntimeConfig };