@expeed/ngx-data-mapper 1.0.0

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@expeed/ngx-data-mapper",
+  "version": "1.0.0",
+  "description": "Visual data mapping components for Angular - drag-and-drop field mapping with transformations, schema editor with JSON Schema export",
+  "keywords": [
+    "angular",
+    "data-mapper",
+    "field-mapping",
+    "schema-editor",
+    "json-schema",
+    "drag-drop",
+    "visual-mapping",
+    "etl",
+    "data-transformation"
+  ],
+  "license": "Apache-2.0",
+  "author": "Expeed Software",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Expeed-Software/angular-data-mapper.git"
+  },
+  "homepage": "https://github.com/Expeed-Software/angular-data-mapper#readme",
+  "bugs": {
+    "url": "https://github.com/Expeed-Software/angular-data-mapper/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "peerDependencies": {
+    "@angular/common": "^21.0.0",
+    "@angular/core": "^21.0.0",
+    "@angular/forms": "^21.0.0",
+    "@angular/cdk": "^21.0.0",
+    "@angular/material": "^21.0.0"
+  },
+  "dependencies": {
+    "tslib": "^2.3.0"
+  },
+  "sideEffects": false,
+  "module": "fesm2022/expeed-ngx-data-mapper.mjs",
+  "typings": "types/expeed-ngx-data-mapper.d.ts",
+  "exports": {
+    "./package.json": {
+      "default": "./package.json"
+    },
+    ".": {
+      "types": "./types/expeed-ngx-data-mapper.d.ts",
+      "default": "./fesm2022/expeed-ngx-data-mapper.mjs"
+    }
+  }
+}

package/types/expeed-ngx-data-mapper.d.ts

@@ -0,0 +1,604 @@
+import * as _angular_core from '@angular/core';
+import { AfterViewInit, OnDestroy, EventEmitter, ElementRef, QueryList, OnInit, OnChanges, SimpleChanges } from '@angular/core';
+
+interface SchemaField {
+    id: string;
+    name: string;
+    type: 'string' | 'number' | 'boolean' | 'object' | 'array' | 'date';
+    path: string;
+    children?: SchemaField[];
+    expanded?: boolean;
+    description?: string;
+    isArrayItem?: boolean;
+    parentArrayPath?: string;
+}
+interface JsonSchema {
+    name: string;
+    fields: SchemaField[];
+}
+type TransformationType = 'direct' | 'concat' | 'substring' | 'replace' | 'uppercase' | 'lowercase' | 'dateFormat' | 'extractYear' | 'extractMonth' | 'extractDay' | 'extractHour' | 'extractMinute' | 'extractSecond' | 'numberFormat' | 'template' | 'custom';
+interface TransformationConfig {
+    type: TransformationType;
+    separator?: string;
+    template?: string;
+    startIndex?: number;
+    endIndex?: number;
+    searchValue?: string;
+    replaceValue?: string;
+    inputFormat?: string;
+    outputFormat?: string;
+    decimalPlaces?: number;
+    prefix?: string;
+    suffix?: string;
+    expression?: string;
+}
+interface FieldMapping {
+    id: string;
+    sourceFields: SchemaField[];
+    targetField: SchemaField;
+    transformation: TransformationConfig;
+    isArrayMapping?: boolean;
+    arrayMappingId?: string;
+    isArrayToObjectMapping?: boolean;
+    arrayToObjectMappingId?: string;
+}
+type FilterOperator = 'equals' | 'notEquals' | 'contains' | 'notContains' | 'startsWith' | 'endsWith' | 'greaterThan' | 'lessThan' | 'greaterThanOrEqual' | 'lessThanOrEqual' | 'isEmpty' | 'isNotEmpty' | 'isTrue' | 'isFalse';
+interface FilterCondition {
+    id: string;
+    type: 'condition';
+    field: string;
+    fieldName: string;
+    operator: FilterOperator;
+    value: string | number | boolean;
+    valueType: 'string' | 'number' | 'boolean';
+}
+interface FilterGroup {
+    id: string;
+    type: 'group';
+    logic: 'and' | 'or';
+    children: FilterItem[];
+}
+type FilterItem = FilterCondition | FilterGroup;
+interface ArrayFilterConfig {
+    enabled: boolean;
+    root: FilterGroup;
+}
+interface ArrayMapping {
+    id: string;
+    sourceArray: SchemaField;
+    targetArray: SchemaField;
+    itemMappings: FieldMapping[];
+    filter?: ArrayFilterConfig;
+}
+type ArraySelectionMode = 'first' | 'last' | 'condition';
+interface ArraySelectorConfig {
+    mode: ArraySelectionMode;
+    condition?: FilterGroup;
+}
+interface ArrayToObjectMapping {
+    id: string;
+    sourceArray: SchemaField;
+    targetObject: SchemaField;
+    selector: ArraySelectorConfig;
+    itemMappings: FieldMapping[];
+}
+interface ConnectionPoint {
+    fieldId: string;
+    side: 'source' | 'target';
+    x: number;
+    y: number;
+}
+interface Connection {
+    id: string;
+    mappingId: string;
+    sourcePoints: ConnectionPoint[];
+    targetPoint: ConnectionPoint;
+    transformation: TransformationConfig;
+}
+interface DragState {
+    isDragging: boolean;
+    sourceField: SchemaField | null;
+    startPoint: {
+        x: number;
+        y: number;
+    } | null;
+    currentPoint: {
+        x: number;
+        y: number;
+    } | null;
+}
+interface DefaultValue {
+    id: string;
+    targetField: SchemaField;
+    value: string | number | boolean | Date | null;
+    valueType: 'string' | 'number' | 'boolean' | 'date';
+}
+
+declare class MappingService {
+    private mappings;
+    private arrayMappings;
+    private arrayToObjectMappings;
+    private defaultValues;
+    private selectedMappingId;
+    private dragState;
+    readonly allMappings: _angular_core.Signal<FieldMapping[]>;
+    readonly allArrayMappings: _angular_core.Signal<ArrayMapping[]>;
+    readonly allArrayToObjectMappings: _angular_core.Signal<ArrayToObjectMapping[]>;
+    readonly allDefaultValues: _angular_core.Signal<DefaultValue[]>;
+    readonly selectedMapping: _angular_core.Signal<FieldMapping | null>;
+    readonly currentDragState: _angular_core.Signal<DragState>;
+    private generateId;
+    startDrag(field: SchemaField, startPoint: {
+        x: number;
+        y: number;
+    }): void;
+    updateDragPosition(currentPoint: {
+        x: number;
+        y: number;
+    }): void;
+    endDrag(): void;
+    createMapping(sourceFields: SchemaField[], targetField: SchemaField, transformation?: TransformationConfig): FieldMapping;
+    private createArrayMapping;
+    private createArrayToObjectMapping;
+    private findOrCreateArrayContext;
+    private findOrCreateArrayToObjectContext;
+    getArrayMapping(id: string): ArrayMapping | undefined;
+    getArrayMappingForField(field: SchemaField): ArrayMapping | undefined;
+    removeArrayMapping(arrayMappingId: string): void;
+    updateArrayFilter(arrayMappingId: string, filter: ArrayFilterConfig | undefined): void;
+    getArrayToObjectMapping(id: string): ArrayToObjectMapping | undefined;
+    updateArrayToObjectSelector(mappingId: string, selector: ArraySelectorConfig): void;
+    removeArrayToObjectMapping(mappingId: string): void;
+    updateMapping(mappingId: string, updates: Partial<FieldMapping>): void;
+    updateTransformation(mappingId: string, transformation: TransformationConfig): void;
+    removeMapping(mappingId: string): void;
+    removeSourceFromMapping(mappingId: string, sourceFieldId: string): void;
+    selectMapping(mappingId: string | null): void;
+    getMappingForTarget(targetFieldId: string): FieldMapping | undefined;
+    getMappingsForSource(sourceFieldId: string): FieldMapping[];
+    clearAllMappings(): void;
+    setDefaultValue(targetField: SchemaField, value: string | number | boolean | Date | null): DefaultValue;
+    getDefaultValue(targetFieldId: string): DefaultValue | undefined;
+    removeDefaultValue(targetFieldId: string): void;
+    hasDefaultValue(targetFieldId: string): boolean;
+    private getValueType;
+    exportMappings(): string;
+    importMappings(json: string): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<MappingService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<MappingService>;
+}
+
+declare class TransformationService {
+    applyTransformation(sourceValues: Record<string, unknown>, sourceFields: SchemaField[], config: TransformationConfig): string;
+    private getValueByPath;
+    private applyTemplate;
+    private formatDate;
+    private extractDatePart;
+    private formatNumber;
+    private applyCustomExpression;
+    getTransformationLabel(type: TransformationType): string;
+    getAvailableTransformations(): {
+        type: TransformationType;
+        label: string;
+        category?: string;
+    }[];
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TransformationService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<TransformationService>;
+}
+
+interface Point {
+    x: number;
+    y: number;
+}
+interface ConnectionPath {
+    id: string;
+    mappingId: string;
+    path: string;
+    sourcePoints: Point[];
+    targetPoint: Point;
+    midPoint: Point;
+    isSelected: boolean;
+    hasTransformation: boolean;
+}
+declare class SvgConnectorService {
+    createBezierPath(start: Point, end: Point): string;
+    createMultiSourcePath(sources: Point[], target: Point): {
+        paths: string[];
+        mergePoint: Point;
+    };
+    getMidPoint(start: Point, end: Point): Point;
+    getMultiSourceMidPoint(sources: Point[], target: Point): Point;
+    calculateConnectionPoint(rect: DOMRect, side: 'source' | 'target', containerRect: DOMRect): Point;
+    isPointNearPath(point: Point, pathStart: Point, pathEnd: Point, threshold?: number): boolean;
+    createDragPath(start: Point, end: Point): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SvgConnectorService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<SvgConnectorService>;
+}
+
+interface JsonSchemaDefinition {
+    type?: string;
+    format?: string;
+    properties?: Record<string, JsonSchemaDefinition>;
+    items?: JsonSchemaDefinition;
+    $ref?: string;
+    description?: string;
+    enum?: string[];
+    required?: string[];
+    additionalProperties?: boolean | JsonSchemaDefinition;
+}
+interface SchemaDocument {
+    $ref?: string;
+    $defs?: Record<string, JsonSchemaDefinition>;
+    definitions?: Record<string, JsonSchemaDefinition>;
+    exclude?: string[];
+    include?: string[];
+    properties?: Record<string, JsonSchemaDefinition>;
+    type?: string;
+    title?: string;
+    description?: string;
+}
+interface ModelRegistry {
+    [modelName: string]: JsonSchemaDefinition;
+}
+declare class SchemaParserService {
+    private modelRegistry;
+    private idCounter;
+    registerModels(models: ModelRegistry): void;
+    clearRegistry(): void;
+    parseSchema(schemaJson: string | SchemaDocument, schemaName?: string): JsonSchema;
+    private resolveRef;
+    private buildFields;
+    private buildField;
+    private mapType;
+    private applyExclude;
+    private applyInclude;
+    private hasIncludedChild;
+    createSchemaFromRef(modelRef: string, options?: {
+        exclude?: string[];
+        include?: string[];
+        title?: string;
+    }): SchemaDocument;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SchemaParserService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<SchemaParserService>;
+}
+
+interface FieldPositionEvent {
+    field: SchemaField;
+    element: HTMLElement;
+    rect: DOMRect;
+}
+declare class SchemaTreeComponent implements AfterViewInit, OnDestroy {
+    schema: {
+        name: string;
+        fields: SchemaField[];
+    };
+    side: 'source' | 'target';
+    mappings: FieldMapping[];
+    defaultValues: DefaultValue[];
+    fieldDragStart: EventEmitter<FieldPositionEvent>;
+    fieldDragEnd: EventEmitter<void>;
+    fieldDrop: EventEmitter<FieldPositionEvent>;
+    fieldPositionsChanged: EventEmitter<Map<string, DOMRect>>;
+    fieldDefaultValueClick: EventEmitter<FieldPositionEvent>;
+    schemaFieldsContainer: ElementRef<HTMLDivElement>;
+    fieldItems: QueryList<ElementRef>;
+    private mappingService;
+    private resizeObserver;
+    private scrollHandler;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    onScroll(): void;
+    emitFieldPositions(): void;
+    toggleExpand(field: SchemaField, event: Event): void;
+    onDragStart(event: MouseEvent, field: SchemaField): void;
+    onDragOver(event: DragEvent): void;
+    onDrop(event: MouseEvent, field: SchemaField): void;
+    getTypeIcon(type: string): string;
+    isFieldMapped(field: SchemaField): boolean;
+    getFieldMappingCount(field: SchemaField): number;
+    hasDefaultValue(field: SchemaField): boolean;
+    getDefaultValueDisplay(field: SchemaField): string;
+    onFieldClick(event: MouseEvent, field: SchemaField): void;
+    trackByFieldId(index: number, field: SchemaField): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SchemaTreeComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SchemaTreeComponent, "schema-tree", never, { "schema": { "alias": "schema"; "required": false; }; "side": { "alias": "side"; "required": false; }; "mappings": { "alias": "mappings"; "required": false; }; "defaultValues": { "alias": "defaultValues"; "required": false; }; }, { "fieldDragStart": "fieldDragStart"; "fieldDragEnd": "fieldDragEnd"; "fieldDrop": "fieldDrop"; "fieldPositionsChanged": "fieldPositionsChanged"; "fieldDefaultValueClick": "fieldDefaultValueClick"; }, never, never, true, never>;
+}
+
+interface VisualConnection {
+    id: string;
+    mappingId: string;
+    paths: string[];
+    midPoint: Point;
+    targetPoint: Point;
+    hasTransformation: boolean;
+    isSelected: boolean;
+    isArrayMapping: boolean;
+    isArrayToObjectMapping: boolean;
+    hasFilter: boolean;
+}
+declare class DataMapperComponent implements AfterViewInit, OnDestroy {
+    sourceSchema: JsonSchema;
+    targetSchema: JsonSchema;
+    sampleData: Record<string, unknown>;
+    mappingsChange: EventEmitter<FieldMapping[]>;
+    svgContainer: ElementRef<HTMLDivElement>;
+    svgElement: ElementRef<SVGSVGElement>;
+    private mappingService;
+    private svgConnectorService;
+    private transformationService;
+    private sourcePositions;
+    private targetPositions;
+    connections: _angular_core.WritableSignal<VisualConnection[]>;
+    dragPath: _angular_core.WritableSignal<string | null>;
+    selectedMappingId: _angular_core.WritableSignal<string | null>;
+    popoverPosition: _angular_core.WritableSignal<{
+        x: number;
+        y: number;
+    } | null>;
+    showArrayFilterModal: _angular_core.WritableSignal<boolean>;
+    selectedArrayMapping: _angular_core.WritableSignal<ArrayMapping | null>;
+    showArraySelectorModal: _angular_core.WritableSignal<boolean>;
+    selectedArrayToObjectMapping: _angular_core.WritableSignal<ArrayToObjectMapping | null>;
+    showDefaultValuePopover: _angular_core.WritableSignal<boolean>;
+    selectedDefaultValueField: _angular_core.WritableSignal<SchemaField | null>;
+    defaultValuePopoverPosition: _angular_core.WritableSignal<{
+        x: number;
+        y: number;
+    } | null>;
+    readonly mappings: _angular_core.Signal<FieldMapping[]>;
+    readonly arrayMappings: _angular_core.Signal<ArrayMapping[]>;
+    readonly defaultValues: _angular_core.Signal<DefaultValue[]>;
+    readonly selectedMapping: _angular_core.Signal<FieldMapping | null>;
+    readonly showPopover: _angular_core.Signal<boolean>;
+    private isDragging;
+    private dragSourceField;
+    private dragStartPoint;
+    private resizeObserver;
+    ngAfterViewInit(): void;
+    ngOnDestroy(): void;
+    private setupResizeObserver;
+    onSourcePositionsChanged(positions: Map<string, DOMRect>): void;
+    onTargetPositionsChanged(positions: Map<string, DOMRect>): void;
+    onFieldDragStart(event: FieldPositionEvent): void;
+    onMouseMove(event: MouseEvent): void;
+    onMouseUp(event: MouseEvent): void;
+    onFieldDrop(event: FieldPositionEvent): void;
+    onConnectionClick(connection: VisualConnection, event: MouseEvent): void;
+    onTransformationNodeClick(connection: VisualConnection, event: MouseEvent): void;
+    onArrayFilterSave(filter: ArrayFilterConfig | undefined): void;
+    closeArrayFilterModal(): void;
+    onArraySelectorSave(selector: ArraySelectorConfig): void;
+    closeArraySelectorModal(): void;
+    onDefaultValueClick(event: FieldPositionEvent): void;
+    onDefaultValueSave(value: string | number | boolean | Date | null): void;
+    onDefaultValueDelete(): void;
+    closeDefaultValuePopover(): void;
+    getExistingDefaultValue(fieldId: string): DefaultValue | undefined;
+    onPopoverSave(config: TransformationConfig): void;
+    onPopoverDelete(): void;
+    closePopover(): void;
+    private updateConnections;
+    getTransformationIcon(mappingId: string): string;
+    clearAllMappings(): void;
+    exportMappings(): string;
+    importMappings(json: string): void;
+    trackByConnectionId(index: number, connection: VisualConnection): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DataMapperComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DataMapperComponent, "data-mapper", never, { "sourceSchema": { "alias": "sourceSchema"; "required": false; }; "targetSchema": { "alias": "targetSchema"; "required": false; }; "sampleData": { "alias": "sampleData"; "required": false; }; }, { "mappingsChange": "mappingsChange"; }, never, never, true, never>;
+}
+
+interface EditorField {
+    id: string;
+    name: string;
+    type: 'string' | 'number' | 'boolean' | 'date' | 'object' | 'array';
+    description?: string;
+    required?: boolean;
+    allowedValues?: string[];
+    children?: EditorField[];
+    expanded?: boolean;
+    isEditing?: boolean;
+    isEditingValues?: boolean;
+}
+interface SchemaDefinition {
+    name: string;
+    fields: EditorField[];
+}
+declare class SchemaEditorComponent {
+    set schema(value: SchemaDefinition | null);
+    schemaChange: EventEmitter<SchemaDefinition>;
+    save: EventEmitter<SchemaDefinition>;
+    schemaName: _angular_core.WritableSignal<string>;
+    fields: _angular_core.WritableSignal<EditorField[]>;
+    fieldTypes: Array<{
+        value: string;
+        label: string;
+        icon: string;
+    }>;
+    private generateId;
+    private cloneFields;
+    getTypeIcon(type: string): string;
+    addField(): void;
+    addChildField(parent: EditorField): void;
+    deleteField(field: EditorField, parentList: EditorField[]): void;
+    duplicateField(field: EditorField, parentList: EditorField[]): void;
+    toggleExpand(field: EditorField): void;
+    startEdit(field: EditorField): void;
+    stopEdit(field: EditorField): void;
+    onFieldNameChange(field: EditorField, event: Event): void;
+    onFieldTypeChange(field: EditorField, type: string): void;
+    toggleRequired(field: EditorField): void;
+    onDescriptionChange(field: EditorField, description: string): void;
+    toggleValuesEditor(field: EditorField): void;
+    addAllowedValue(field: EditorField, input: HTMLInputElement): void;
+    removeAllowedValue(field: EditorField, index: number): void;
+    onAllowedValueKeydown(event: KeyboardEvent, field: EditorField, input: HTMLInputElement): void;
+    onFieldNameKeydown(event: KeyboardEvent, field: EditorField): void;
+    moveFieldUp(field: EditorField, parentList: EditorField[]): void;
+    moveFieldDown(field: EditorField, parentList: EditorField[]): void;
+    canIndent(field: EditorField, parentList: EditorField[]): boolean;
+    indentField(field: EditorField, parentList: EditorField[]): void;
+    outdentField(field: EditorField, parentList: EditorField[], level: number): void;
+    private findParentOfList;
+    private findParentList;
+    onSchemaNameChange(name: string, input?: HTMLInputElement): void;
+    private emitChange;
+    onSave(): void;
+    toJson(): string;
+    toJsonSchema(): object;
+    private fieldToJsonSchema;
+    private stripEditingState;
+    trackByFieldId(index: number, field: EditorField): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SchemaEditorComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SchemaEditorComponent, "schema-editor", never, { "schema": { "alias": "schema"; "required": false; }; }, { "schemaChange": "schemaChange"; "save": "save"; }, never, never, true, never>;
+}
+
+declare class TransformationPopoverComponent implements OnInit, OnChanges {
+    mapping: FieldMapping;
+    position: {
+        x: number;
+        y: number;
+    };
+    sampleData: Record<string, unknown>;
+    save: EventEmitter<TransformationConfig>;
+    delete: EventEmitter<void>;
+    close: EventEmitter<void>;
+    private transformationService;
+    transformationType: TransformationType;
+    config: TransformationConfig;
+    preview: string;
+    availableTransformations: {
+        type: TransformationType;
+        label: string;
+        category?: string;
+    }[];
+    ngOnInit(): void;
+    ngOnChanges(changes: SimpleChanges): void;
+    private initFromMapping;
+    onTypeChange(): void;
+    private getDefaultTemplate;
+    updatePreview(): void;
+    onConfigChange(): void;
+    onSave(): void;
+    onDelete(): void;
+    onClose(): void;
+    getSourceFieldNames(): string;
+    getPopoverStyle(): Record<string, string>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<TransformationPopoverComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<TransformationPopoverComponent, "transformation-popover", never, { "mapping": { "alias": "mapping"; "required": false; }; "position": { "alias": "position"; "required": false; }; "sampleData": { "alias": "sampleData"; "required": false; }; }, { "save": "save"; "delete": "delete"; "close": "close"; }, never, never, true, never>;
+}
+
+interface OperatorOption$1 {
+    value: FilterOperator;
+    label: string;
+    needsValue: boolean;
+}
+declare class ArrayFilterModalComponent implements OnInit {
+    arrayMapping: ArrayMapping;
+    save: EventEmitter<ArrayFilterConfig | undefined>;
+    close: EventEmitter<void>;
+    filterEnabled: _angular_core.WritableSignal<boolean>;
+    rootGroup: _angular_core.WritableSignal<FilterGroup>;
+    availableFields: _angular_core.Signal<{
+        path: string;
+        name: string;
+        type: string;
+    }[]>;
+    stringOperators: OperatorOption$1[];
+    numberOperators: OperatorOption$1[];
+    booleanOperators: OperatorOption$1[];
+    ngOnInit(): void;
+    private createEmptyGroup;
+    private generateId;
+    private cloneGroup;
+    private collectFields;
+    getOperatorsForField(fieldPath: string): OperatorOption$1[];
+    getFieldType(fieldPath: string): string;
+    operatorNeedsValue(operator: FilterOperator): boolean;
+    isCondition(item: FilterItem): item is FilterCondition;
+    isGroup(item: FilterItem): item is FilterGroup;
+    addCondition(group: FilterGroup): void;
+    addGroup(parentGroup: FilterGroup): void;
+    removeItem(parentGroup: FilterGroup, itemId: string): void;
+    onFieldChange(condition: FilterCondition, fieldPath: string): void;
+    onOperatorChange(condition: FilterCondition, operator: FilterOperator): void;
+    onValueChange(condition: FilterCondition, value: string | boolean): void;
+    onLogicChange(group: FilterGroup, logic: 'and' | 'or'): void;
+    private triggerUpdate;
+    hasConditions(group: FilterGroup): boolean;
+    countConditions(group: FilterGroup): number;
+    onSave(): void;
+    onClose(): void;
+    onBackdropClick(event: MouseEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ArrayFilterModalComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ArrayFilterModalComponent, "array-filter-modal", never, { "arrayMapping": { "alias": "arrayMapping"; "required": true; }; }, { "save": "save"; "close": "close"; }, never, never, true, never>;
+}
+
+interface OperatorOption {
+    value: FilterOperator;
+    label: string;
+    needsValue: boolean;
+}
+declare class ArraySelectorModalComponent implements OnInit {
+    mapping: ArrayToObjectMapping;
+    save: EventEmitter<ArraySelectorConfig>;
+    close: EventEmitter<void>;
+    selectionMode: _angular_core.WritableSignal<ArraySelectionMode>;
+    conditionGroup: _angular_core.WritableSignal<FilterGroup>;
+    availableFields: _angular_core.Signal<{
+        path: string;
+        name: string;
+        type: string;
+    }[]>;
+    stringOperators: OperatorOption[];
+    numberOperators: OperatorOption[];
+    booleanOperators: OperatorOption[];
+    ngOnInit(): void;
+    private createEmptyGroup;
+    private generateId;
+    private cloneGroup;
+    private collectFields;
+    getOperatorsForField(fieldPath: string): OperatorOption[];
+    operatorNeedsValue(operator: FilterOperator): boolean;
+    isCondition(item: FilterItem): item is FilterCondition;
+    isGroup(item: FilterItem): item is FilterGroup;
+    addCondition(group: FilterGroup): void;
+    addGroup(parentGroup: FilterGroup): void;
+    removeItem(parentGroup: FilterGroup, itemId: string): void;
+    onFieldChange(condition: FilterCondition, fieldPath: string): void;
+    onOperatorChange(condition: FilterCondition, operator: FilterOperator): void;
+    onValueChange(condition: FilterCondition, value: string | boolean): void;
+    onLogicChange(group: FilterGroup, logic: 'and' | 'or'): void;
+    private triggerUpdate;
+    onSave(): void;
+    onClose(): void;
+    onBackdropClick(event: MouseEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ArraySelectorModalComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ArraySelectorModalComponent, "array-selector-modal", never, { "mapping": { "alias": "mapping"; "required": true; }; }, { "save": "save"; "close": "close"; }, never, never, true, never>;
+}
+
+declare class DefaultValuePopoverComponent implements OnInit {
+    field: SchemaField;
+    existingValue?: DefaultValue;
+    position: {
+        x: number;
+        y: number;
+    };
+    save: EventEmitter<string | number | boolean | Date | null>;
+    delete: EventEmitter<void>;
+    close: EventEmitter<void>;
+    stringValue: string;
+    numberValue: number | null;
+    booleanValue: boolean;
+    dateValue: Date | null;
+    ngOnInit(): void;
+    get fieldType(): string;
+    onSave(): void;
+    onDelete(): void;
+    onClose(): void;
+    onBackdropClick(event: MouseEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<DefaultValuePopoverComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<DefaultValuePopoverComponent, "default-value-popover", never, { "field": { "alias": "field"; "required": false; }; "existingValue": { "alias": "existingValue"; "required": false; }; "position": { "alias": "position"; "required": false; }; }, { "save": "save"; "delete": "delete"; "close": "close"; }, never, never, true, never>;
+}
+
+export { ArrayFilterModalComponent, ArraySelectorModalComponent, DataMapperComponent, DefaultValuePopoverComponent, MappingService, SchemaEditorComponent, SchemaParserService, SchemaTreeComponent, SvgConnectorService, TransformationPopoverComponent, TransformationService };
+export type { ArrayFilterConfig, ArrayMapping, ArraySelectionMode, ArraySelectorConfig, ArrayToObjectMapping, Connection, ConnectionPath, ConnectionPoint, DefaultValue, DragState, EditorField, FieldMapping, FieldPositionEvent, FilterCondition, FilterGroup, FilterItem, FilterOperator, JsonSchema, JsonSchemaDefinition, ModelRegistry, Point, SchemaDefinition, SchemaDocument, SchemaField, TransformationConfig, TransformationType };