@uigraph/sdk 1.1.34

package/dist/index.d.cts

@@ -0,0 +1,767 @@
+import { a as MermaidNode, c as SequenceParticipant, d as ServerComponentField, f as ServerComponentFieldInput, i as MermaidEdge, l as SubgraphInfo, n as RFComponentField, o as SequenceDiagramData, r as ReactFlowData, s as SequenceMessage, t as CustomData, u as SubgraphLayout } from "./__index.BC7AYPW7.cjs";
+import { t as ComponentInputType } from "./__component-type.tW2Xh7Xk.cjs";
+import { t as contextSchema } from "./__headless.B7jwmaZK.cjs";
+import z$1, { z } from "zod";
+import { Edge, Node } from "@xyflow/react";
+
+//#region src/react-flow/data-source/nosql-schema.d.ts
+type NestedFieldInternal$1 = {
+  id: string;
+  name: string;
+  type: string;
+  required: boolean;
+  fields?: NestedFieldInternal$1[];
+  itemType?: string;
+  itemFields?: NestedFieldInternal$1[];
+};
+type MongoNestedFieldInternal$1 = {
+  id: string;
+  name: string;
+  type: string;
+  required: boolean;
+  fields?: MongoNestedFieldInternal$1[];
+  itemType?: string;
+  itemFields?: MongoNestedFieldInternal$1[];
+  refCollectionId?: string | null;
+};
+type DynamoAttributeInternal$1 = {
+  id: string;
+  name: string;
+  type: string;
+  required: boolean;
+  notes?: string;
+  fields?: DynamoAttributeInternal$1[];
+  itemType?: string;
+  itemFields?: DynamoAttributeInternal$1[];
+};
+declare const DynamoEditorSchema$1: z.ZodObject<{
+  name: z.ZodString;
+  description: z.ZodString;
+  dialect: z.ZodLiteral<"dynamodb">;
+  primaryKey: z.ZodObject<{
+    partitionKey: z.ZodString;
+    partitionKeyType: z.ZodOptional<z.ZodString>;
+    sortKey: z.ZodString;
+    sortKeyType: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>;
+  globalSecondaryIndexes: z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    partitionKey: z.ZodString;
+    partitionKeyType: z.ZodOptional<z.ZodString>;
+    sortKey: z.ZodOptional<z.ZodString>;
+    sortKeyType: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>>;
+  attributes: z.ZodArray<z.ZodType<DynamoAttributeInternal$1, unknown, z.core.$ZodTypeInternals<DynamoAttributeInternal$1, unknown>>>;
+}, z.core.$strip>;
+declare const MongoEditorSchema$1: z.ZodObject<{
+  name: z.ZodString;
+  description: z.ZodString;
+  dialect: z.ZodLiteral<"mongodb">;
+  collections: z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    tags: z.ZodString;
+    description: z.ZodString;
+    fields: z.ZodArray<z.ZodType<MongoNestedFieldInternal$1, unknown, z.core.$ZodTypeInternals<MongoNestedFieldInternal$1, unknown>>>;
+    indexes: z.ZodArray<z.ZodObject<{
+      id: z.ZodString;
+      name: z.ZodString;
+      fields: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        fieldName: z.ZodString;
+        order: z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<-1>]>;
+      }, z.core.$strip>>;
+      unique: z.ZodBoolean;
+    }, z.core.$strip>>;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+declare const JsonEditorSchema$1: z.ZodObject<{
+  name: z.ZodString;
+  description: z.ZodString;
+  dialect: z.ZodLiteral<"json">;
+  collections: z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    label: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    tags: z.ZodOptional<z.ZodString>;
+    fields: z.ZodArray<z.ZodLazy<z.ZodObject<{
+      id: z.ZodString;
+      name: z.ZodString;
+      type: z.ZodString;
+      required: z.ZodBoolean;
+      isArray: z.ZodBoolean;
+      reference: z.ZodOptional<z.ZodObject<{
+        collectionId: z.ZodString;
+        fieldId: z.ZodOptional<z.ZodString>;
+      }, z.core.$strip>>;
+      notes: z.ZodOptional<z.ZodString>;
+      fields: z.ZodOptional<z.ZodArray<z.ZodType<NestedFieldInternal$1, unknown, z.core.$ZodTypeInternals<NestedFieldInternal$1, unknown>>>>;
+      itemType: z.ZodOptional<z.ZodString>;
+      itemFields: z.ZodOptional<z.ZodArray<z.ZodType<NestedFieldInternal$1, unknown, z.core.$ZodTypeInternals<NestedFieldInternal$1, unknown>>>>;
+    }, z.core.$strip>>>;
+    indexes: z.ZodArray<z.ZodObject<{
+      id: z.ZodString;
+      name: z.ZodString;
+      fields: z.ZodArray<z.ZodString>;
+      unique: z.ZodBoolean;
+      ttl: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    sample: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+//#endregion
+//#region src/react-flow/data-source/index.d.ts
+interface DataSource {
+  id: string;
+  name: string;
+  sourceType: 'file' | 'manual' | 'editor';
+  sourceContent?: z$1.infer<typeof JsonEditorSchema$1> | z$1.infer<typeof DynamoEditorSchema$1> | z$1.infer<typeof MongoEditorSchema$1>;
+  dialect: SchemaDialect;
+  schemaAst: SchemaAST;
+  createdAt: number;
+  modifiedAt: number | null;
+}
+//#endregion
+//#region src/react-flow/node/sql-node.d.ts
+interface DatabaseTableSQLNodeData extends Record<string, unknown> {
+  style?: {
+    baseColor?: string;
+  };
+  isForcedOpen?: boolean;
+  localTable?: {
+    baseId: string;
+    tableId: string;
+  };
+  serviceTable?: {
+    serviceId: string;
+    serviceDbId: string;
+    tableName: string;
+  };
+}
+//#endregion
+//#region src/sql-parser/types.d.ts
+type SchemaDialect = 'mysql' | 'sqlite' | 'postgresql' | 'json' | 'mongodb' | 'dynamodb';
+interface SchemaAST {
+  dialect: SchemaDialect;
+  tables: TableAST[];
+  metadata?: {
+    version?: string;
+    createdAt?: Date;
+    sourceFile?: string;
+  };
+}
+interface TableAST {
+  type: 'table';
+  id: string;
+  name: string;
+  columns: ColumnAST[];
+  constraints: ConstraintAST[];
+  indexes: IndexAST[];
+  options?: TableOptionsAST;
+  position?: {
+    x: number;
+    y: number;
+  };
+}
+interface ColumnAST {
+  type: 'column';
+  name: string;
+  dataType: DataTypeAST;
+  nullable: boolean;
+  defaultValue?: DefaultValueAST;
+  autoIncrement?: boolean;
+  comment?: string;
+  collation?: string;
+  charset?: string;
+}
+interface DataTypeAST {
+  name: string;
+  unsigned?: boolean;
+  timezone?: boolean;
+  parameters?: (number | string)[];
+}
+interface DefaultValueAST {
+  type: 'literal' | 'function' | 'expression';
+  value: string | number | boolean | null;
+  raw?: string;
+}
+type ConstraintAST = PrimaryKeyConstraintAST | ForeignKeyConstraintAST | UniqueConstraintAST | CheckConstraintAST;
+interface PrimaryKeyConstraintAST {
+  type: 'primary_key';
+  name?: string;
+  columns: string[];
+}
+interface ForeignKeyConstraintAST {
+  type: 'foreign_key';
+  name?: string;
+  columns: string[];
+  referencedTable: string;
+  referencedColumns: string[];
+  onDelete?: ReferentialActionAST;
+  onUpdate?: ReferentialActionAST;
+}
+interface UniqueConstraintAST {
+  type: 'unique';
+  name?: string;
+  columns: string[];
+}
+interface CheckConstraintAST {
+  type: 'check';
+  name?: string;
+  expression: string;
+}
+type ReferentialActionAST = 'CASCADE' | 'SET NULL' | 'SET DEFAULT' | 'RESTRICT' | 'NO ACTION';
+interface IndexAST {
+  type: 'index';
+  name: string;
+  columns: IndexColumnAST[];
+  unique: boolean;
+  method?: IndexMethodAST;
+  where?: string;
+}
+interface IndexColumnAST {
+  name: string;
+  order?: 'ASC' | 'DESC';
+  length?: number;
+}
+type IndexMethodAST = 'btree' | 'hash' | 'gin' | 'gist' | 'spgist' | 'brin';
+interface TableOptionsAST {
+  engine?: string;
+  charset?: string;
+  collation?: string;
+  autoIncrement?: number;
+  comment?: string;
+  rowFormat?: string;
+  tablespace?: string;
+}
+interface SchemaUIRepresentation {
+  tables: {
+    id: string;
+    name: string;
+    position: {
+      x: number;
+      y: number;
+    };
+    columns: {
+      name: string;
+      type: string;
+      isPrimaryKey: boolean;
+      isForeignKey: boolean;
+      nullable: boolean;
+      defaultValue?: string;
+    }[];
+  }[];
+  relationships: {
+    id: string;
+    sourceTable: string;
+    sourceColumn: string;
+    targetTable: string;
+    targetColumn: string;
+    onDelete?: string;
+    onUpdate?: string;
+  }[];
+}
+interface TParsedTable {
+  name: string;
+  columns: TParsedColumn[];
+  primaryKeys: string[];
+  foreignKeys: TParsedForeignKey[];
+  indexes: TParsedIndex[];
+}
+interface TParsedColumn {
+  name: string;
+  type: string;
+  nullable: boolean;
+  defaultValue?: string;
+  description?: string;
+}
+interface TParsedForeignKey {
+  columnName: string;
+  referencedTable: string;
+  referencedColumn: string;
+  constraintName?: string;
+}
+interface TParsedIndex {
+  name: string;
+  columns: string[];
+  unique: boolean;
+}
+interface TParsedSchema {
+  tables: TParsedTable[];
+  relationships: TParsedForeignKey[];
+}
+//#endregion
+//#region src/sql-parser/ast-converter.d.ts
+/**
+ * Convert AST to UI representation (ReactFlow nodes and edges)
+ */
+declare class AstToUiConverter {
+  /**
+   * Convert schema AST to ReactFlow nodes and edges
+   */
+  static updateReactFlow({
+    nodes,
+    edges,
+    schema,
+    sourceId,
+    oldDataSources
+  }: {
+    nodes: Node[];
+    edges: Edge[];
+    sourceId: string;
+    schema: SchemaAST;
+    oldDataSources: DataSource[];
+  }): {
+    nodes: Node[];
+    edges: Edge[];
+  };
+  static toReactFlow(schema: SchemaAST, sourceId: string): {
+    nodes: Node<DatabaseTableSQLNodeData>[];
+    edges: Edge[];
+  };
+  /**
+   * Calculate smart layout that groups related tables and separates unrelated ones
+   */
+  private static calculateSmartLayout;
+  /**
+   * Layout a component of related tables using Sugiyama layered approach
+   */
+  private static layoutComponentHierarchical;
+  /**
+   * Convert table AST to ReactFlow node
+   */
+  private static tableAstToNode;
+  /**
+   * Extract primary keys from table
+   */
+  static extractPrimaryKeys(table: TableAST): string[];
+  /**
+   * Extract foreign keys from table
+   */
+  static extractForeignKeys(table: TableAST): ForeignKeyConstraintAST[];
+  /**
+   * Format data type for display
+   */
+  static formatDataType(column: ColumnAST): string;
+  /**
+   * Create edges from foreign key relationships
+   */
+  private static createEdgesFromTable;
+}
+//#endregion
+//#region src/sql-parser/ast-generator.d.ts
+declare class AstToSqlGenerator {
+  private dialect;
+  private indentSize;
+  constructor(dialect?: SchemaDialect, indentSize?: number);
+  private generateNoSQL;
+  /**
+   * Generate SQL from schema AST
+   */
+  private generateSQL;
+  generate(schema: SchemaAST): string;
+  /**
+   * Generate CREATE TABLE statement
+   */
+  private generateCreateTable;
+  /**
+   * Generate column definition
+   */
+  private generateColumn;
+  /**
+   * Generate data type string
+   */
+  private generateDataType;
+  /**
+   * Generate default value
+   */
+  private generateDefaultValue;
+  /**
+   * Generate constraint definition
+   */
+  private generateConstraint;
+  /**
+   * Generate PRIMARY KEY constraint
+   */
+  private generatePrimaryKey;
+  /**
+   * Generate FOREIGN KEY constraint
+   */
+  private generateForeignKey;
+  /**
+   * Generate UNIQUE constraint
+   */
+  private generateUnique;
+  /**
+   * Generate CHECK constraint
+   */
+  private generateCheck;
+  /**
+   * Generate INDEX definition (MySQL inline)
+   */
+  private generateIndex;
+  /**
+   * Generate INDEX definition (PostgreSQL separate statement)
+   */
+  private generatePostgresIndex;
+  /**
+   * Generate table options
+   */
+  private generateTableOptions;
+  /**
+   * Quote identifier based on dialect
+   */
+  private quoteIdentifier;
+}
+//#endregion
+//#region src/sql-parser/ast-parser.d.ts
+declare class SqlToAstParser {
+  private dialect;
+  constructor(dialect?: SchemaDialect);
+  /**
+   * Parse SQL dump into AST
+   */
+  private parseSQL;
+  private parseNoSQL;
+  parse(sqlContent: string, useStrictNoSQL?: boolean): SchemaAST;
+  /**
+   * Auto-detect SQL dialect
+   */
+  static detectDialect(sqlContent: string): SchemaDialect;
+  /**
+   * Extract all tables from SQL content
+   */
+  private extractTables;
+  private extractCreateTableComponents;
+  private findClosingParenthesis;
+  private applyAlterTableStatements;
+  /**
+   * Clean SQL content (remove comments, normalize whitespace)
+   */
+  private cleanSql;
+  /**
+   * Clean identifier (remove quotes, backticks)
+   */
+  private cleanIdentifier;
+  private normalizeTableName;
+  private normalizeTableKey;
+  private parseNoSqlType;
+  /**
+   * Parse table definition
+   */
+  private parseTableDefinition;
+  /**
+   * Split table body by commas, respecting parentheses
+   */
+  private splitTableBody;
+  /**
+   * Parse column definition
+   */
+  private parseColumn;
+  private splitColumnDefinition;
+  private applyInlineColumnConstraints;
+  /**
+   * Parse data type
+   */
+  private parseDataType;
+  /**
+   * Parse default value
+   */
+  private parseDefaultValue;
+  /**
+   * Parse constraint
+   */
+  private parseConstraint;
+  /**
+   * Parse primary key constraint
+   */
+  private parsePrimaryKey;
+  /**
+   * Parse foreign key constraint
+   */
+  private parseForeignKey;
+  private extractReferentialAction;
+  /**
+   * Parse unique constraint
+   */
+  private parseUnique;
+  /**
+   * Parse check constraint
+   */
+  private parseCheck;
+  /**
+   * Parse index definition
+   */
+  private parseIndex;
+  /**
+   * Parse table options
+   */
+  private parseTableOptions;
+}
+//#endregion
+//#region src/sql-parser/utils.d.ts
+declare function generateTableNodeId(baseId: string, tableId?: string | null): string;
+declare function generateUUID(): string;
+//#endregion
+//#region src/nosql-parser/nosql-schema.d.ts
+type NoSQLDialect = 'dynamodb' | 'mongodb' | 'json';
+type NestedFieldInternal = {
+  id: string;
+  name: string;
+  type: string;
+  required: boolean;
+  fields?: NestedFieldInternal[];
+  itemType?: string;
+  itemFields?: NestedFieldInternal[];
+};
+declare const DialectIdSchema: z.ZodUnion<readonly [z.ZodLiteral<NoSQLDialect>, z.ZodLiteral<NoSQLDialect>, z.ZodLiteral<NoSQLDialect>]>;
+declare const EditorSupportedDialectSchema: z.ZodUnion<[z.ZodUnion<readonly [z.ZodLiteral<NoSQLDialect>, z.ZodLiteral<NoSQLDialect>, z.ZodLiteral<NoSQLDialect>]>, z.ZodLiteral<"nosql">]>;
+declare const BasicDetailsSchema: z.ZodObject<{
+  name: z.ZodString;
+  description: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+declare const NestedFieldSchema: z.ZodType<NestedFieldInternal>;
+declare const NoSqlFieldSchema: z.ZodLazy<z.ZodObject<{
+  id: z.ZodString;
+  name: z.ZodString;
+  type: z.ZodString;
+  required: z.ZodBoolean;
+  isArray: z.ZodBoolean;
+  reference: z.ZodOptional<z.ZodObject<{
+    collectionId: z.ZodString;
+    fieldId: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>>;
+  notes: z.ZodOptional<z.ZodString>;
+  fields: z.ZodOptional<z.ZodArray<z.ZodType<NestedFieldInternal, unknown, z.core.$ZodTypeInternals<NestedFieldInternal, unknown>>>>;
+  itemType: z.ZodOptional<z.ZodString>;
+  itemFields: z.ZodOptional<z.ZodArray<z.ZodType<NestedFieldInternal, unknown, z.core.$ZodTypeInternals<NestedFieldInternal, unknown>>>>;
+}, z.core.$strip>>;
+declare const DocumentIndexSchema: z.ZodObject<{
+  id: z.ZodString;
+  name: z.ZodString;
+  fields: z.ZodArray<z.ZodString>;
+  unique: z.ZodBoolean;
+  ttl: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+declare const DocumentCollectionSchema: z.ZodObject<{
+  id: z.ZodString;
+  name: z.ZodString;
+  label: z.ZodOptional<z.ZodString>;
+  description: z.ZodOptional<z.ZodString>;
+  tags: z.ZodOptional<z.ZodString>;
+  fields: z.ZodArray<z.ZodLazy<z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    type: z.ZodString;
+    required: z.ZodBoolean;
+    isArray: z.ZodBoolean;
+    reference: z.ZodOptional<z.ZodObject<{
+      collectionId: z.ZodString;
+      fieldId: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    notes: z.ZodOptional<z.ZodString>;
+    fields: z.ZodOptional<z.ZodArray<z.ZodType<NestedFieldInternal, unknown, z.core.$ZodTypeInternals<NestedFieldInternal, unknown>>>>;
+    itemType: z.ZodOptional<z.ZodString>;
+    itemFields: z.ZodOptional<z.ZodArray<z.ZodType<NestedFieldInternal, unknown, z.core.$ZodTypeInternals<NestedFieldInternal, unknown>>>>;
+  }, z.core.$strip>>>;
+  indexes: z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    fields: z.ZodArray<z.ZodString>;
+    unique: z.ZodBoolean;
+    ttl: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>>;
+  sample: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type MongoNestedFieldInternal = {
+  id: string;
+  name: string;
+  type: string;
+  required: boolean;
+  fields?: MongoNestedFieldInternal[];
+  itemType?: string;
+  itemFields?: MongoNestedFieldInternal[];
+  refCollectionId?: string | null;
+};
+declare const MongoNestedFieldSchema: z.ZodType<MongoNestedFieldInternal>;
+declare const MongoIndexFieldSchema: z.ZodObject<{
+  id: z.ZodString;
+  fieldName: z.ZodString;
+  order: z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<-1>]>;
+}, z.core.$strip>;
+declare const MongoIndexSchema: z.ZodObject<{
+  id: z.ZodString;
+  name: z.ZodString;
+  fields: z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    fieldName: z.ZodString;
+    order: z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<-1>]>;
+  }, z.core.$strip>>;
+  unique: z.ZodBoolean;
+}, z.core.$strip>;
+declare const MongoCollectionSchema: z.ZodObject<{
+  id: z.ZodString;
+  name: z.ZodString;
+  tags: z.ZodString;
+  description: z.ZodString;
+  fields: z.ZodArray<z.ZodType<MongoNestedFieldInternal, unknown, z.core.$ZodTypeInternals<MongoNestedFieldInternal, unknown>>>;
+  indexes: z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    fields: z.ZodArray<z.ZodObject<{
+      id: z.ZodString;
+      fieldName: z.ZodString;
+      order: z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<-1>]>;
+    }, z.core.$strip>>;
+    unique: z.ZodBoolean;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+type DynamoAttributeInternal = {
+  id: string;
+  name: string;
+  type: string;
+  required: boolean;
+  notes?: string;
+  fields?: DynamoAttributeInternal[];
+  itemType?: string;
+  itemFields?: DynamoAttributeInternal[];
+};
+declare const DynamoGsiSchema: z.ZodObject<{
+  id: z.ZodString;
+  name: z.ZodString;
+  partitionKey: z.ZodString;
+  partitionKeyType: z.ZodOptional<z.ZodString>;
+  sortKey: z.ZodOptional<z.ZodString>;
+  sortKeyType: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+declare const DynamoAttributeSchema: z.ZodType<DynamoAttributeInternal>;
+declare const DynamoEditorSchema: z.ZodObject<{
+  name: z.ZodString;
+  description: z.ZodOptional<z.ZodString>;
+  dialect: z.ZodLiteral<"dynamodb">;
+  primaryKey: z.ZodObject<{
+    partitionKey: z.ZodString;
+    partitionKeyType: z.ZodOptional<z.ZodString>;
+    sortKey: z.ZodOptional<z.ZodString>;
+    sortKeyType: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>;
+  globalSecondaryIndexes: z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    partitionKey: z.ZodString;
+    partitionKeyType: z.ZodOptional<z.ZodString>;
+    sortKey: z.ZodOptional<z.ZodString>;
+    sortKeyType: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>>;
+  attributes: z.ZodArray<z.ZodType<DynamoAttributeInternal, unknown, z.core.$ZodTypeInternals<DynamoAttributeInternal, unknown>>>;
+}, z.core.$strip>;
+declare const MongoEditorSchema: z.ZodObject<{
+  name: z.ZodString;
+  description: z.ZodOptional<z.ZodString>;
+  dialect: z.ZodLiteral<"mongodb">;
+  collections: z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    tags: z.ZodString;
+    description: z.ZodString;
+    fields: z.ZodArray<z.ZodType<MongoNestedFieldInternal, unknown, z.core.$ZodTypeInternals<MongoNestedFieldInternal, unknown>>>;
+    indexes: z.ZodArray<z.ZodObject<{
+      id: z.ZodString;
+      name: z.ZodString;
+      fields: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        fieldName: z.ZodString;
+        order: z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<-1>]>;
+      }, z.core.$strip>>;
+      unique: z.ZodBoolean;
+    }, z.core.$strip>>;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+declare const JsonEditorSchema: z.ZodObject<{
+  name: z.ZodString;
+  description: z.ZodOptional<z.ZodString>;
+  dialect: z.ZodLiteral<"json">;
+  collections: z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    label: z.ZodOptional<z.ZodString>;
+    description: z.ZodOptional<z.ZodString>;
+    tags: z.ZodOptional<z.ZodString>;
+    fields: z.ZodArray<z.ZodLazy<z.ZodObject<{
+      id: z.ZodString;
+      name: z.ZodString;
+      type: z.ZodString;
+      required: z.ZodBoolean;
+      isArray: z.ZodBoolean;
+      reference: z.ZodOptional<z.ZodObject<{
+        collectionId: z.ZodString;
+        fieldId: z.ZodOptional<z.ZodString>;
+      }, z.core.$strip>>;
+      notes: z.ZodOptional<z.ZodString>;
+      fields: z.ZodOptional<z.ZodArray<z.ZodType<NestedFieldInternal, unknown, z.core.$ZodTypeInternals<NestedFieldInternal, unknown>>>>;
+      itemType: z.ZodOptional<z.ZodString>;
+      itemFields: z.ZodOptional<z.ZodArray<z.ZodType<NestedFieldInternal, unknown, z.core.$ZodTypeInternals<NestedFieldInternal, unknown>>>>;
+    }, z.core.$strip>>>;
+    indexes: z.ZodArray<z.ZodObject<{
+      id: z.ZodString;
+      name: z.ZodString;
+      fields: z.ZodArray<z.ZodString>;
+      unique: z.ZodBoolean;
+      ttl: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    sample: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+//#endregion
+//#region src/nosql-parser/convert-ast.d.ts
+declare function convertDynamoSchemaToAst(schema: z.infer<typeof DynamoEditorSchema>): SchemaAST;
+declare function convertMongoSchemaToAst(schema: z.infer<typeof MongoEditorSchema>): SchemaAST;
+declare function convertJsonSchemaToAst(schema: z.infer<typeof JsonEditorSchema>): SchemaAST;
+//#endregion
+//#region src/nosql-parser/index.d.ts
+declare function convertNoSQLToAst(input: unknown): SchemaAST;
+//#endregion
+//#region src/sync-data/sync-base-data.d.ts
+type Options = {
+  keepPrev?: boolean;
+  includeNodePositions?: boolean;
+  includeNodeDimensions?: boolean;
+};
+declare function syncBaseData(prev: ReactFlowData, next: ReactFlowData, options?: Options): ReactFlowData;
+//#endregion
+//#region src/mermaid-converter/mermaid-sanitizer.d.ts
+declare function sanitizeMermaidLabels(src: string): string;
+//#endregion
+//#region src/mermaid-converter/mermaid-to-react-flow.d.ts
+declare function convertMermaidToReactFlow(mermaidCode: string): Promise<ReactFlowData>;
+//#endregion
+//#region src/components/data-structure.d.ts
+declare function flattenMetaData(fields: ServerComponentField[], fieldsValues: ServerComponentField[]): Record<string, any>;
+declare function buildMetaData(fields: ServerComponentField[], data: Record<string, any | null>): ServerComponentFieldInput[];
+//#endregion
+//#region src/mermaid-converter/context/convert-with-context.d.ts
+type ResolverOptions = {
+  repositionNodes?: boolean;
+  resolveCloudIcon?: (cloud: string | undefined, service: string) => Promise<string | undefined | null>;
+};
+declare function convertMermaidToReactFlowWithContext(mermaidCode: string, context: z$1.infer<typeof contextSchema>, options?: ResolverOptions): Promise<ReactFlowData>;
+//#endregion
+//#region src/uig-converter/types.d.ts
+type UiGraphInput = {
+  nodes: Node[];
+  edges: Edge[];
+};
+type UiGraphOptions = {
+  detailedContext?: boolean;
+};
+type UigOutput = {
+  mermaid: string;
+  context: z$1.infer<typeof contextSchema>;
+};
+//#endregion
+//#region src/uig-converter/index.d.ts
+declare function convertUiGraphToMermaid(input: UiGraphInput, options?: UiGraphOptions): UigOutput;
+//#endregion
+export { AstToSqlGenerator, AstToUiConverter, BasicDetailsSchema, CheckConstraintAST, ColumnAST, ComponentInputType, ConstraintAST, CustomData, DataTypeAST, DefaultValueAST, DialectIdSchema, DocumentCollectionSchema, DocumentIndexSchema, DynamoAttributeSchema, DynamoEditorSchema, DynamoGsiSchema, EditorSupportedDialectSchema, ForeignKeyConstraintAST, IndexAST, IndexColumnAST, IndexMethodAST, JsonEditorSchema, MermaidEdge, MermaidNode, MongoCollectionSchema, MongoEditorSchema, MongoIndexFieldSchema, MongoIndexSchema, MongoNestedFieldSchema, NestedFieldSchema, NoSqlFieldSchema, PrimaryKeyConstraintAST, RFComponentField, ReactFlowData, ReferentialActionAST, SchemaAST, SchemaDialect, SchemaUIRepresentation, SequenceDiagramData, SequenceMessage, SequenceParticipant, ServerComponentField, ServerComponentFieldInput, SqlToAstParser, SubgraphInfo, SubgraphLayout, TParsedColumn, TParsedForeignKey, TParsedIndex, TParsedSchema, TParsedTable, TableAST, TableOptionsAST, UniqueConstraintAST, buildMetaData, contextSchema, convertDynamoSchemaToAst, convertJsonSchemaToAst, convertMermaidToReactFlow, convertMermaidToReactFlowWithContext, convertMongoSchemaToAst, convertNoSQLToAst, convertUiGraphToMermaid, flattenMetaData, generateTableNodeId, generateUUID, sanitizeMermaidLabels, syncBaseData };