@epistola.app/valtimo-plugin 0.0.1 → 0.2.0

package/src/lib/components/generate-document-configuration/generate-document-configuration.component.ts

@@ -1,422 +0,0 @@
-import {Component, EventEmitter, Input, OnDestroy, OnInit, Output} from '@angular/core';
-import {CommonModule} from '@angular/common';
-import {FormsModule} from '@angular/forms';
-import {
-  FunctionConfigurationComponent,
-  PluginConfigurationData,
-  PluginTranslatePipeModule
-} from '@valtimo/plugin';
-import {FormModule, FormOutput, InputModule, SelectItem, SelectModule} from '@valtimo/components';
-import {CaseManagementParams, ManagementContext} from '@valtimo/shared';
-import {ProcessLinkStateService} from '@valtimo/process-link';
-import {BehaviorSubject, combineLatest, merge, Observable, of, Subject, Subscription} from 'rxjs';
-import {catchError, filter, map, take, takeUntil} from 'rxjs/operators';
-import {GenerateDocumentConfig, TemplateField, VariantInfo} from '../../models';
-import {EpistolaPluginService} from '../../services';
-import {DataMappingTreeComponent} from '../data-mapping-tree/data-mapping-tree.component';
-
-export type VariantSelectionMode = 'explicit' | 'attributes';
-
-@Component({
-  selector: 'epistola-generate-document-configuration',
-  templateUrl: './generate-document-configuration.component.html',
-  styleUrls: ['./generate-document-configuration.component.scss'],
-  standalone: true,
-  imports: [
-    CommonModule,
-    FormsModule,
-    PluginTranslatePipeModule,
-    FormModule,
-    InputModule,
-    SelectModule,
-    DataMappingTreeComponent
-  ]
-})
-export class GenerateDocumentConfigurationComponent
-  implements FunctionConfigurationComponent, OnInit, OnDestroy
-{
-  // Required inputs from FunctionConfigurationComponent
-  @Input() save$!: Observable<void>;
-  @Input() disabled$!: Observable<boolean>;
-  @Input() pluginId!: string;
-  @Input() prefillConfiguration$!: Observable<GenerateDocumentConfig>;
-
-  // Optional inputs from FunctionConfigurationComponent
-  @Input() selectedPluginConfigurationData$?: Observable<PluginConfigurationData>;
-  @Input() context$?: Observable<[ManagementContext, CaseManagementParams]>;
-
-  @Output() valid: EventEmitter<boolean> = new EventEmitter<boolean>();
-  @Output() configuration: EventEmitter<GenerateDocumentConfig> = new EventEmitter<GenerateDocumentConfig>();
-
-  // Template options loaded from API
-  templateOptions$ = new BehaviorSubject<SelectItem[]>([]);
-  templatesLoading$ = new BehaviorSubject<boolean>(false);
-
-  // Variant options loaded based on selected template
-  variantOptions$ = new BehaviorSubject<SelectItem[]>([]);
-  variantsLoading$ = new BehaviorSubject<boolean>(false);
-
-  // Environment options loaded from API
-  environmentOptions$ = new BehaviorSubject<SelectItem[]>([]);
-  environmentsLoading$ = new BehaviorSubject<boolean>(false);
-
-  // Template fields for data mapping
-  templateFields$ = new BehaviorSubject<TemplateField[]>([]);
-  templateFieldsLoading$ = new BehaviorSubject<boolean>(false);
-
-  // Current data mapping (nested structure mirroring template schema)
-  dataMapping$ = new BehaviorSubject<Record<string, any>>({});
-
-  // Prefill data mapping observable for the tree
-  prefillDataMapping$!: Observable<Record<string, any>>;
-
-  outputFormatOptions: SelectItem[] = [
-    {id: 'PDF', text: 'PDF'},
-    {id: 'HTML', text: 'HTML'}
-  ];
-
-  // Show data mapping builder only when template is selected
-  readonly selectedTemplateId$ = new BehaviorSubject<string>('');
-  readonly selectedVariantId$ = new BehaviorSubject<string>('');
-
-  // Variant selection mode: 'explicit' (dropdown) or 'attributes' (key-value pairs)
-  variantSelectionMode: VariantSelectionMode = 'explicit';
-
-  // Variant attributes for attribute-based selection
-  variantAttributeEntries: {key: string; value: string}[] = [];
-
-  // Case definition key from context (for ValuePathSelector)
-  caseDefinitionKey: string | null = null;
-
-  // Discovered process variables
-  processVariables: string[] = [];
-
-  // Required fields status
-  requiredFieldsStatus: {mapped: number; total: number} = {mapped: 0, total: 0};
-
-  private readonly destroy$ = new Subject<void>();
-  private saveSubscription!: Subscription;
-  private readonly formValue$ = new BehaviorSubject<Partial<GenerateDocumentConfig> | null>(null);
-  private readonly valid$ = new BehaviorSubject<boolean>(false);
-  private pluginConfigurationId$ = new BehaviorSubject<string>('');
-
-  constructor(
-    private readonly epistolaPluginService: EpistolaPluginService,
-    private readonly processLinkStateService: ProcessLinkStateService
-  ) {}
-
-  ngOnInit(): void {
-    this.initContext();
-    this.initPrefillDataMapping();
-    this.initPluginConfiguration();
-    this.initTemplatesLoading();
-    this.initEnvironmentsLoading();
-    this.initVariantsLoading();
-    this.initTemplateFieldsLoading();
-    this.openSaveSubscription();
-  }
-
-  ngOnDestroy(): void {
-    this.destroy$.next();
-    this.destroy$.complete();
-    this.saveSubscription?.unsubscribe();
-  }
-
-  formValueChange(formOutput: FormOutput): void {
-    const formValue = formOutput as unknown as Partial<GenerateDocumentConfig>;
-    this.formValue$.next(formValue);
-
-    // Update selected template if changed (also clears variant selection)
-    if (formValue.templateId && formValue.templateId !== this.selectedTemplateId$.getValue()) {
-      this.selectedTemplateId$.next(formValue.templateId);
-      this.selectedVariantId$.next('');
-    }
-
-    // Update selected variant if changed
-    if (formValue.variantId && formValue.variantId !== this.selectedVariantId$.getValue()) {
-      this.selectedVariantId$.next(formValue.variantId);
-    }
-
-    this.handleValid(formValue);
-  }
-
-  onDataMappingChange(mapping: Record<string, any>): void {
-    this.dataMapping$.next(mapping);
-    // Re-validate when data mapping changes
-    const currentFormValue = this.formValue$.getValue();
-    if (currentFormValue) {
-      this.handleValid(currentFormValue);
-    }
-  }
-
-  onRequiredFieldsStatusChange(status: {mapped: number; total: number}): void {
-    this.requiredFieldsStatus = status;
-    // Re-validate when required fields status changes
-    const currentFormValue = this.formValue$.getValue();
-    if (currentFormValue) {
-      this.handleValid(currentFormValue);
-    }
-  }
-
-  onVariantSelectionModeChange(mode: VariantSelectionMode): void {
-    this.variantSelectionMode = mode;
-    if (mode === 'attributes' && this.variantAttributeEntries.length === 0) {
-      this.variantAttributeEntries = [{key: '', value: ''}];
-    }
-    // Re-validate
-    const currentFormValue = this.formValue$.getValue();
-    if (currentFormValue) {
-      this.handleValid(currentFormValue);
-    }
-  }
-
-  addAttributeEntry(): void {
-    this.variantAttributeEntries = [...this.variantAttributeEntries, {key: '', value: ''}];
-    this.revalidate();
-  }
-
-  removeAttributeEntry(index: number): void {
-    this.variantAttributeEntries = this.variantAttributeEntries.filter((_, i) => i !== index);
-    this.revalidate();
-  }
-
-  onAttributeEntryChange(): void {
-    this.revalidate();
-  }
-
-  private revalidate(): void {
-    const currentFormValue = this.formValue$.getValue();
-    if (currentFormValue) {
-      this.handleValid(currentFormValue);
-    }
-  }
-
-  private formatAttributes(attributes: Record<string, string>): string {
-    const entries = Object.entries(attributes || {});
-    if (entries.length === 0) return '';
-    return ` (${entries.map(([k, v]) => `${k}=${v}`).join(', ')})`;
-  }
-
-  private initContext(): void {
-    if (this.context$) {
-      this.context$.pipe(
-        takeUntil(this.destroy$),
-        filter(([context]) => context === 'case')
-      ).subscribe(([, params]) => {
-        this.caseDefinitionKey = params.caseDefinitionKey;
-      });
-    }
-  }
-
-  private initPrefillDataMapping(): void {
-    if (this.prefillConfiguration$) {
-      this.prefillDataMapping$ = this.prefillConfiguration$.pipe(
-        map(config => config?.dataMapping || {})
-      );
-
-      // Also set initial selected template, variant mode, and variant
-      this.prefillConfiguration$.pipe(
-        takeUntil(this.destroy$),
-        filter(config => !!config?.templateId)
-      ).subscribe(config => {
-        this.selectedTemplateId$.next(config.templateId);
-        if (config.variantAttributes && Object.keys(config.variantAttributes).length > 0) {
-          this.variantSelectionMode = 'attributes';
-          this.variantAttributeEntries = Object.entries(config.variantAttributes)
-            .map(([key, value]) => ({key, value}));
-        } else if (config.variantId) {
-          this.variantSelectionMode = 'explicit';
-          this.selectedVariantId$.next(config.variantId);
-        }
-        if (config.dataMapping) {
-          this.dataMapping$.next(config.dataMapping);
-        }
-      });
-    } else {
-      this.prefillDataMapping$ = new BehaviorSubject({}).asObservable();
-    }
-  }
-
-  private initPluginConfiguration(): void {
-    const sources: Observable<string>[] = [];
-
-    // Create mode: framework emits when user selects a plugin configuration
-    if (this.selectedPluginConfigurationData$) {
-      sources.push(
-        this.selectedPluginConfigurationData$.pipe(
-          filter(config => !!config?.configurationId),
-          map(config => config.configurationId)
-        )
-      );
-    }
-
-    // Edit mode: read pluginConfigurationId from the ProcessLink entity
-    // (selectedPluginConfigurationData$ does not emit in edit mode)
-    sources.push(
-      this.processLinkStateService.selectedProcessLink$.pipe(
-        filter(processLink => !!processLink?.pluginConfigurationId),
-        map(processLink => processLink.pluginConfigurationId!)
-      )
-    );
-
-    merge(...sources).pipe(
-      takeUntil(this.destroy$)
-    ).subscribe(configurationId => {
-      this.pluginConfigurationId$.next(configurationId);
-    });
-  }
-
-  private initTemplatesLoading(): void {
-    this.pluginConfigurationId$.pipe(
-      takeUntil(this.destroy$),
-      filter(id => !!id)
-    ).subscribe(configurationId => {
-      this.templatesLoading$.next(true);
-      this.epistolaPluginService.getTemplates(configurationId).pipe(
-        takeUntil(this.destroy$),
-        catchError(() => of([]))
-      ).subscribe(templates => {
-        const options: SelectItem[] = templates.map(t => ({
-          id: t.id,
-          text: t.name
-        }));
-        this.templateOptions$.next(options);
-        this.templatesLoading$.next(false);
-      });
-    });
-  }
-
-  private initEnvironmentsLoading(): void {
-    this.pluginConfigurationId$.pipe(
-      takeUntil(this.destroy$),
-      filter(id => !!id)
-    ).subscribe(configurationId => {
-      this.environmentsLoading$.next(true);
-      this.epistolaPluginService.getEnvironments(configurationId).pipe(
-        takeUntil(this.destroy$),
-        catchError(() => of([]))
-      ).subscribe(environments => {
-        const options: SelectItem[] = environments.map(e => ({
-          id: e.id,
-          text: e.name
-        }));
-        this.environmentOptions$.next(options);
-        this.environmentsLoading$.next(false);
-      });
-    });
-  }
-
-  private initVariantsLoading(): void {
-    combineLatest([
-      this.pluginConfigurationId$,
-      this.selectedTemplateId$
-    ]).pipe(
-      takeUntil(this.destroy$),
-      filter(([configId, templateId]) => !!configId && !!templateId)
-    ).subscribe(([configurationId, templateId]) => {
-      this.variantsLoading$.next(true);
-      this.epistolaPluginService.getVariants(configurationId, templateId).pipe(
-        takeUntil(this.destroy$),
-        catchError(() => of([]))
-      ).subscribe(variants => {
-        const options: SelectItem[] = variants.map(v => ({
-          id: v.id,
-          text: v.name + this.formatAttributes(v.attributes)
-        }));
-        this.variantOptions$.next(options);
-        this.variantsLoading$.next(false);
-      });
-    });
-  }
-
-  private initTemplateFieldsLoading(): void {
-    combineLatest([
-      this.pluginConfigurationId$,
-      this.selectedTemplateId$
-    ]).pipe(
-      takeUntil(this.destroy$),
-      filter(([configId, templateId]) => !!configId && !!templateId)
-    ).subscribe(([configurationId, templateId]) => {
-      this.templateFieldsLoading$.next(true);
-      this.epistolaPluginService.getTemplateDetails(configurationId, templateId).pipe(
-        takeUntil(this.destroy$),
-        catchError(() => of({fields: []} as any))
-      ).subscribe(details => {
-        this.templateFields$.next(details.fields || []);
-        this.templateFieldsLoading$.next(false);
-      });
-
-      // Also load process variables if we have a case context
-      this.loadProcessVariables();
-    });
-  }
-
-  private loadProcessVariables(): void {
-    // Try to discover process variables (best-effort, may not always have context)
-    if (this.caseDefinitionKey) {
-      this.epistolaPluginService.getProcessVariables(this.caseDefinitionKey).pipe(
-        takeUntil(this.destroy$),
-        catchError(() => of([]))
-      ).subscribe(variables => {
-        this.processVariables = variables;
-      });
-    }
-  }
-
-  private handleValid(formValue: Partial<GenerateDocumentConfig>): void {
-    const baseComplete = !!(
-      formValue?.templateId &&
-      formValue?.outputFormat &&
-      formValue?.filename &&
-      formValue?.resultProcessVariable
-    );
-
-    // Variant selection: if attribute mode is used, all entries must have both key and value filled.
-    // Neither variant nor attributes are required — omitting both uses the template's default variant.
-    let variantValid = true;
-    if (this.variantSelectionMode === 'attributes' && this.variantAttributeEntries.length > 0) {
-      variantValid = this.variantAttributeEntries.every(e => !!e.key && !!e.value);
-    }
-
-    // Check if all required template fields are mapped
-    const requiredFieldsMapped = this.requiredFieldsStatus.total === 0 ||
-      this.requiredFieldsStatus.mapped === this.requiredFieldsStatus.total;
-
-    const valid = baseComplete && variantValid && requiredFieldsMapped;
-    this.valid$.next(valid);
-    this.valid.emit(valid);
-  }
-
-  private openSaveSubscription(): void {
-    this.saveSubscription = this.save$?.subscribe(() => {
-      combineLatest([this.formValue$, this.valid$, this.dataMapping$])
-        .pipe(take(1))
-        .subscribe(([formValue, valid, dataMapping]) => {
-          if (valid && formValue) {
-            const config: GenerateDocumentConfig = {
-              templateId: formValue.templateId!,
-              environmentId: formValue.environmentId || undefined,
-              dataMapping: dataMapping,
-              outputFormat: formValue.outputFormat as 'PDF' | 'HTML',
-              filename: formValue.filename!,
-              correlationId: formValue.correlationId || undefined,
-              resultProcessVariable: formValue.resultProcessVariable!
-            };
-
-            if (this.variantSelectionMode === 'explicit') {
-              config.variantId = formValue.variantId!;
-            } else {
-              config.variantAttributes = {};
-              for (const entry of this.variantAttributeEntries) {
-                if (entry.key && entry.value) {
-                  config.variantAttributes[entry.key] = entry.value;
-                }
-              }
-            }
-
-            this.configuration.emit(config);
-          }
-        });
-    });
-  }
-}

package/src/lib/epistola.module.ts

@@ -1,50 +0,0 @@
-import {NgModule} from '@angular/core';
-import {CommonModule} from '@angular/common';
-import {HttpClientModule} from '@angular/common/http';
-import {PluginTranslatePipeModule} from '@valtimo/plugin';
-import {FormModule, InputModule, SelectModule} from '@valtimo/components';
-import {EpistolaConfigurationComponent} from './components/epistola-configuration/epistola-configuration.component';
-import {
-  GenerateDocumentConfigurationComponent
-} from './components/generate-document-configuration/generate-document-configuration.component';
-import {
-  CheckJobStatusConfigurationComponent
-} from './components/check-job-status-configuration/check-job-status-configuration.component';
-import {
-  DownloadDocumentConfigurationComponent
-} from './components/download-document-configuration/download-document-configuration.component';
-import {DataMappingTreeComponent} from './components/data-mapping-tree/data-mapping-tree.component';
-import {FieldTreeComponent} from './components/field-tree/field-tree.component';
-import {EpistolaDownloadComponent} from './components/epistola-download/epistola-download.component';
-import {EpistolaPluginService} from './services';
-
-@NgModule({
-  imports: [
-    CommonModule,
-    HttpClientModule,
-    PluginTranslatePipeModule,
-    FormModule,
-    InputModule,
-    SelectModule,
-    EpistolaConfigurationComponent,
-    GenerateDocumentConfigurationComponent,
-    CheckJobStatusConfigurationComponent,
-    DownloadDocumentConfigurationComponent,
-    DataMappingTreeComponent,
-    FieldTreeComponent,
-    EpistolaDownloadComponent
-  ],
-  exports: [
-    EpistolaConfigurationComponent,
-    GenerateDocumentConfigurationComponent,
-    CheckJobStatusConfigurationComponent,
-    DownloadDocumentConfigurationComponent,
-    DataMappingTreeComponent,
-    FieldTreeComponent,
-    EpistolaDownloadComponent
-  ],
-  providers: [
-    EpistolaPluginService
-  ]
-})
-export class EpistolaPluginModule {}

package/src/lib/epistola.specification.ts

@@ -1,208 +0,0 @@
-import {PluginSpecification} from '@valtimo/plugin';
-import {EpistolaConfigurationComponent} from './components/epistola-configuration/epistola-configuration.component';
-import {
-  GenerateDocumentConfigurationComponent
-} from './components/generate-document-configuration/generate-document-configuration.component';
-import {
-  CheckJobStatusConfigurationComponent
-} from './components/check-job-status-configuration/check-job-status-configuration.component';
-import {
-  DownloadDocumentConfigurationComponent
-} from './components/download-document-configuration/download-document-configuration.component';
-import {EPISTOLA_PLUGIN_LOGO_BASE64} from './assets';
-
-const epistolaPluginSpecification: PluginSpecification = {
-  // Must match backend @Plugin(key = "epistola")
-  pluginId: 'epistola',
-
-  // Component for plugin-level configuration (tenantId)
-  pluginConfigurationComponent: EpistolaConfigurationComponent,
-
-  // Plugin logo
-  pluginLogoBase64: EPISTOLA_PLUGIN_LOGO_BASE64,
-
-  // Map action keys to their configuration components
-  functionConfigurationComponents: {
-    'generate-document': GenerateDocumentConfigurationComponent,
-    'check-job-status': CheckJobStatusConfigurationComponent,
-    'download-document': DownloadDocumentConfigurationComponent,
-  },
-
-  // Translations
-  pluginTranslations: {
-    nl: {
-      title: 'Epistola Document Suite',
-      description: 'Documentgeneratie met Epistola',
-      configurationTitle: 'Configuratienaam',
-      baseUrl: 'Base URL',
-      baseUrlTooltip: 'De basis URL van de Epistola API (bijv. https://api.epistola.app)',
-      apiKey: 'API Key',
-      apiKeyTooltip: 'De API sleutel voor authenticatie met Epistola',
-      tenantId: 'Tenant ID',
-      tenantIdTooltip: 'De tenant slug in Epistola (3-63 tekens, alleen kleine letters, cijfers en koppeltekens, bijv. "mijn-tenant")',
-      defaultEnvironmentId: 'Standaard Omgeving',
-      defaultEnvironmentIdTooltip: 'De standaard omgeving voor documentgeneratie (3-30 tekens, alleen kleine letters, cijfers en koppeltekens, bijv. "productie")',
-      templateSyncEnabled: 'Template synchronisatie',
-      templateSyncEnabledTooltip: 'Synchroniseer template definities automatisch van het classpath naar Epistola bij het opstarten',
-      'generate-document': 'Genereer Document',
-      templateId: 'Template',
-      templateIdTooltip: 'Selecteer het template dat gebruikt wordt voor documentgeneratie',
-      variantId: 'Variant',
-      variantIdTooltip: 'Selecteer de template variant',
-      variantSelectionMode: 'Variant selectie',
-      variantSelectionModeTooltip: 'Kies hoe de variant geselecteerd wordt',
-      selectByVariant: 'Selecteer variant',
-      selectByAttributes: 'Selecteer op kenmerken',
-      variantAttributes: 'Variant kenmerken',
-      variantAttributesTooltip: 'Kenmerken voor automatische variant selectie. Waarden kunnen expressies zijn (doc:, pv:, case:).',
-      attributeKey: 'Kenmerk',
-      attributeValue: 'Waarde',
-      addAttribute: 'Kenmerk toevoegen',
-      removeAttribute: 'Kenmerk verwijderen',
-      environmentId: 'Omgeving',
-      environmentIdTooltip: 'Selecteer de doelomgeving (optioneel)',
-      correlationId: 'Correlatie ID',
-      correlationIdTooltip: 'Een optioneel correlatie ID voor het traceren van dit verzoek',
-      dataMapping: 'Data Mapping',
-      dataMappingTooltip: 'Koppeling van template velden naar data bronnen (doc:, pv:, case:)',
-      outputFormat: 'Uitvoerformaat',
-      outputFormatTooltip: 'Het gewenste formaat van het gegenereerde document',
-      filename: 'Bestandsnaam',
-      filenameTooltip: 'De bestandsnaam voor het gegenereerde document',
-      resultProcessVariable: 'Resultaat Procesvariabele',
-      resultProcessVariableTooltip: 'De naam van de procesvariabele waarin het request ID wordt opgeslagen',
-      pdf: 'PDF',
-      html: 'HTML',
-      // Data mapping builder translations
-      dataMappingTitle: 'Data Mapping',
-      dataMappingDescription: 'Koppel template velden aan Valtimo data bronnen',
-      templateField: 'Template veld',
-      dataSource: 'Data bron',
-      addMapping: 'Mapping toevoegen',
-      noMappings: 'Nog geen mappings toegevoegd. Klik op "Mapping toevoegen" om te beginnen.',
-      documentFields: 'Document velden',
-      processVariables: 'Procesvariabelen',
-      caseProperties: 'Zaak eigenschappen',
-      sourceType: 'Brontype',
-      sourceTypeDocument: 'Document veld',
-      sourceTypeProcessVariable: 'Procesvariabele',
-      sourceTypeManual: 'Handmatig',
-      requiredFieldsMissing: 'Niet alle verplichte velden zijn gekoppeld',
-      requiredFieldsComplete: 'Alle verplichte velden zijn gekoppeld',
-      validationSummary: 'verplichte velden gekoppeld',
-      fieldRequired: 'Verplicht',
-      fieldOptional: 'Optioneel',
-      mapCollectionTo: 'Koppel collectie aan',
-      browseMode: 'Bladermodus',
-      pvMode: 'Procesvariabele modus',
-      pvPlaceholder: 'Naam procesvariabele',
-      expressionMode: 'Expressiemodus',
-      itemFieldMapping: 'Veldnamen per item koppelen',
-      itemFieldMappingTitle: 'Veldkoppeling per item:',
-      sourceFieldPlaceholder: 'Bronveldnaam',
-      noTemplateFields: 'Geen template velden beschikbaar',
-      // Check job status action
-      'check-job-status': 'Controleer Taakstatus',
-      requestIdVariable: 'Request ID Variabele',
-      requestIdVariableTooltip: 'Naam van de procesvariabele met het Epistola request ID',
-      statusVariable: 'Status Variabele',
-      statusVariableTooltip: 'Naam van de procesvariabele waarin de status wordt opgeslagen',
-      documentIdVariable: 'Document ID Variabele',
-      documentIdVariableTooltip: 'Naam van de procesvariabele waarin het document ID wordt opgeslagen (bij voltooiing)',
-      errorMessageVariable: 'Foutmelding Variabele',
-      errorMessageVariableTooltip: 'Naam van de procesvariabele waarin de foutmelding wordt opgeslagen (bij fout)',
-      // Download document action
-      'download-document': 'Download Document',
-      contentVariable: 'Inhoud Variabele',
-      contentVariableTooltip: 'Naam van de procesvariabele waarin de documentinhoud (Base64) wordt opgeslagen'
-    },
-    en: {
-      title: 'Epistola Document Suite',
-      description: 'Document generation using Epistola',
-      configurationTitle: 'Configuration name',
-      baseUrl: 'Base URL',
-      baseUrlTooltip: 'The base URL of the Epistola API (e.g. https://api.epistola.app)',
-      apiKey: 'API Key',
-      apiKeyTooltip: 'The API key for authentication with Epistola',
-      tenantId: 'Tenant ID',
-      tenantIdTooltip: 'The tenant slug in Epistola (3-63 chars, lowercase letters, digits and hyphens only, e.g. "my-tenant")',
-      defaultEnvironmentId: 'Default Environment',
-      defaultEnvironmentIdTooltip: 'The default environment for document generation (3-30 chars, lowercase letters, digits and hyphens only, e.g. "production")',
-      templateSyncEnabled: 'Template sync',
-      templateSyncEnabledTooltip: 'Automatically synchronize template definitions from classpath to Epistola on startup',
-      'generate-document': 'Generate Document',
-      templateId: 'Template',
-      templateIdTooltip: 'Select the template to use for document generation',
-      variantId: 'Variant',
-      variantIdTooltip: 'Select the template variant',
-      variantSelectionMode: 'Variant selection',
-      variantSelectionModeTooltip: 'Choose how the variant is selected',
-      selectByVariant: 'Select variant',
-      selectByAttributes: 'Select by attributes',
-      variantAttributes: 'Variant attributes',
-      variantAttributesTooltip: 'Attributes for automatic variant selection. Values can be expressions (doc:, pv:, case:).',
-      attributeKey: 'Attribute',
-      attributeValue: 'Value',
-      addAttribute: 'Add attribute',
-      removeAttribute: 'Remove attribute',
-      environmentId: 'Environment',
-      environmentIdTooltip: 'Select the target environment (optional)',
-      correlationId: 'Correlation ID',
-      correlationIdTooltip: 'An optional correlation ID for tracking this request',
-      dataMapping: 'Data Mapping',
-      dataMappingTooltip: 'Mapping of template fields to data sources (doc:, pv:, case:)',
-      outputFormat: 'Output Format',
-      outputFormatTooltip: 'The desired format of the generated document',
-      filename: 'Filename',
-      filenameTooltip: 'The filename for the generated document',
-      resultProcessVariable: 'Result Process Variable',
-      resultProcessVariableTooltip: 'The name of the process variable to store the request ID in',
-      pdf: 'PDF',
-      html: 'HTML',
-      // Data mapping builder translations
-      dataMappingTitle: 'Data Mapping',
-      dataMappingDescription: 'Map template fields to Valtimo data sources',
-      templateField: 'Template field',
-      dataSource: 'Data source',
-      addMapping: 'Add mapping',
-      noMappings: 'No mappings added yet. Click "Add mapping" to start.',
-      documentFields: 'Document fields',
-      processVariables: 'Process variables',
-      caseProperties: 'Case properties',
-      sourceType: 'Source type',
-      sourceTypeDocument: 'Document field',
-      sourceTypeProcessVariable: 'Process variable',
-      sourceTypeManual: 'Manual value',
-      requiredFieldsMissing: 'Not all required fields are mapped',
-      requiredFieldsComplete: 'All required fields are mapped',
-      validationSummary: 'required fields mapped',
-      fieldRequired: 'Required',
-      fieldOptional: 'Optional',
-      mapCollectionTo: 'Map collection to',
-      browseMode: 'Browse mode',
-      pvMode: 'Process variable mode',
-      pvPlaceholder: 'Process variable name',
-      expressionMode: 'Expression mode',
-      itemFieldMapping: 'Map field names per item',
-      itemFieldMappingTitle: 'Item field mapping:',
-      sourceFieldPlaceholder: 'Source field name',
-      noTemplateFields: 'No template fields available',
-      // Check job status action
-      'check-job-status': 'Check Job Status',
-      requestIdVariable: 'Request ID Variable',
-      requestIdVariableTooltip: 'Name of the process variable containing the Epistola request ID',
-      statusVariable: 'Status Variable',
-      statusVariableTooltip: 'Name of the process variable to store the status in',
-      documentIdVariable: 'Document ID Variable',
-      documentIdVariableTooltip: 'Name of the process variable to store the document ID in (when completed)',
-      errorMessageVariable: 'Error Message Variable',
-      errorMessageVariableTooltip: 'Name of the process variable to store the error message in (when failed)',
-      // Download document action
-      'download-document': 'Download Document',
-      contentVariable: 'Content Variable',
-      contentVariableTooltip: 'Name of the process variable to store the document content (Base64) in'
-    }
-  }
-};
-
-export {epistolaPluginSpecification};