@valtimo/plugin 10.3.0 → 10.5.0

package/esm2020/lib/plugins/verzoek/models/verzoek.mjs

@@ -0,0 +1,17 @@
+/*
+ * Copyright 2015-2023 Ritense BV, the Netherlands.
+ *
+ * Licensed under EUPL, Version 1.2 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmVyem9lay5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL3ZhbHRpbW8vcGx1Z2luL3NyYy9saWIvcGx1Z2lucy92ZXJ6b2VrL21vZGVscy92ZXJ6b2VrLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7Ozs7Ozs7OztHQWNHIiwic291cmNlc0NvbnRlbnQiOlsiLypcbiAqIENvcHlyaWdodCAyMDE1LTIwMjMgUml0ZW5zZSBCViwgdGhlIE5ldGhlcmxhbmRzLlxuICpcbiAqIExpY2Vuc2VkIHVuZGVyIEVVUEwsIFZlcnNpb24gMS4yICh0aGUgXCJMaWNlbnNlXCIpO1xuICogeW91IG1heSBub3QgdXNlIHRoaXMgZmlsZSBleGNlcHQgaW4gY29tcGxpYW5jZSB3aXRoIHRoZSBMaWNlbnNlLlxuICogWW91IG1heSBvYnRhaW4gYSBjb3B5IG9mIHRoZSBMaWNlbnNlIGF0XG4gKlxuICogaHR0cHM6Ly9qb2ludXAuZWMuZXVyb3BhLmV1L2NvbGxlY3Rpb24vZXVwbC9ldXBsLXRleHQtZXVwbC0xMlxuICpcbiAqIFVubGVzcyByZXF1aXJlZCBieSBhcHBsaWNhYmxlIGxhdyBvciBhZ3JlZWQgdG8gaW4gd3JpdGluZywgc29mdHdhcmVcbiAqIGRpc3RyaWJ1dGVkIHVuZGVyIHRoZSBMaWNlbnNlIGlzIGRpc3RyaWJ1dGVkIG9uIGFuIFwiQVMgSVNcIiBiYXNpcyxcbiAqIFdJVEhPVVQgV0FSUkFOVElFUyBPUiBDT05ESVRJT05TIE9GIEFOWSBLSU5ELCBlaXRoZXIgZXhwcmVzcyBvciBpbXBsaWVkLlxuICogU2VlIHRoZSBMaWNlbnNlIGZvciB0aGUgc3BlY2lmaWMgbGFuZ3VhZ2UgZ292ZXJuaW5nIHBlcm1pc3Npb25zIGFuZFxuICogbGltaXRhdGlvbnMgdW5kZXIgdGhlIExpY2Vuc2UuXG4gKi9cblxuaW50ZXJmYWNlIE9iamVjdHR5cGUge1xuICBpZDogc3RyaW5nO1xuICB0aXRsZTogc3RyaW5nO1xuICBvYmplY3R0eXBlbkFwaVBsdWdpbkNvbmZpZ3VyYXRpb25JZDogc3RyaW5nO1xuICBvYmplY3R0eXBlSWQ6IHN0cmluZztcbiAgb2JqZWN0ZW5BcGlQbHVnaW5Db25maWd1cmF0aW9uSWQ6IHN0cmluZztcbiAgc2hvd0luRGF0YU1lbnU6IGJvb2xlYW47XG4gIGZvcm1EZWZpbml0aW9uVmlldz86IHN0cmluZztcbiAgZm9ybURlZmluaXRpb25FZGl0Pzogc3RyaW5nO1xufVxuXG50eXBlIE9iamVjdHR5cGVLZXlzID0ga2V5b2YgT2JqZWN0dHlwZTtcblxuaW50ZXJmYWNlIFJvbHR5cGUge1xuICBuYW1lOiBzdHJpbmc7XG4gIHVybDogc3RyaW5nO1xufVxuXG5leHBvcnQge09iamVjdHR5cGUsIE9iamVjdHR5cGVLZXlzLCBSb2x0eXBlfTtcbiJdfQ==

package/esm2020/lib/plugins/verzoek/services/index.mjs

@@ -0,0 +1,17 @@
+/*
+ * Copyright 2015-2023 Ritense BV, the Netherlands.
+ *
+ * Licensed under EUPL, Version 1.2 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export * from './verzoek-plugin.service';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy92YWx0aW1vL3BsdWdpbi9zcmMvbGliL3BsdWdpbnMvdmVyem9lay9zZXJ2aWNlcy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7Ozs7Ozs7Ozs7R0FjRztBQUVILGNBQWMsMEJBQTBCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKlxuICogQ29weXJpZ2h0IDIwMTUtMjAyMyBSaXRlbnNlIEJWLCB0aGUgTmV0aGVybGFuZHMuXG4gKlxuICogTGljZW5zZWQgdW5kZXIgRVVQTCwgVmVyc2lvbiAxLjIgKHRoZSBcIkxpY2Vuc2VcIik7XG4gKiB5b3UgbWF5IG5vdCB1c2UgdGhpcyBmaWxlIGV4Y2VwdCBpbiBjb21wbGlhbmNlIHdpdGggdGhlIExpY2Vuc2UuXG4gKiBZb3UgbWF5IG9idGFpbiBhIGNvcHkgb2YgdGhlIExpY2Vuc2UgYXRcbiAqXG4gKiBodHRwczovL2pvaW51cC5lYy5ldXJvcGEuZXUvY29sbGVjdGlvbi9ldXBsL2V1cGwtdGV4dC1ldXBsLTEyXG4gKlxuICogVW5sZXNzIHJlcXVpcmVkIGJ5IGFwcGxpY2FibGUgbGF3IG9yIGFncmVlZCB0byBpbiB3cml0aW5nLCBzb2Z0d2FyZVxuICogZGlzdHJpYnV0ZWQgdW5kZXIgdGhlIExpY2Vuc2UgaXMgZGlzdHJpYnV0ZWQgb24gYW4gXCJBUyBJU1wiIGJhc2lzLFxuICogV0lUSE9VVCBXQVJSQU5USUVTIE9SIENPTkRJVElPTlMgT0YgQU5ZIEtJTkQsIGVpdGhlciBleHByZXNzIG9yIGltcGxpZWQuXG4gKiBTZWUgdGhlIExpY2Vuc2UgZm9yIHRoZSBzcGVjaWZpYyBsYW5ndWFnZSBnb3Zlcm5pbmcgcGVybWlzc2lvbnMgYW5kXG4gKiBsaW1pdGF0aW9ucyB1bmRlciB0aGUgTGljZW5zZS5cbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL3ZlcnpvZWstcGx1Z2luLnNlcnZpY2UnO1xuIl19

package/esm2020/lib/plugins/verzoek/services/verzoek-plugin.service.mjs

@@ -0,0 +1,43 @@
+/*
+ * Copyright 2015-2023 Ritense BV, the Netherlands.
+ *
+ * Licensed under EUPL, Version 1.2 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { Injectable } from '@angular/core';
+import { catchError, of } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "@valtimo/config";
+export class VerzoekPluginService {
+    constructor(http, configService) {
+        this.http = http;
+        this.valtimoEndpointUri = configService.config?.valtimoApi?.endpointUri;
+    }
+    getAllObjects() {
+        return this.http.get(`${this.valtimoEndpointUri}v1/object/management/configuration`);
+    }
+    getRoltypesByDocumentDefinitionName(documentDefinitionName) {
+        return this.http
+            .get(`${this.valtimoEndpointUri}v1/case-definition/${documentDefinitionName}/zaaktype/roltype`)
+            .pipe(catchError(() => of([])));
+    }
+}
+VerzoekPluginService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: VerzoekPluginService, deps: [{ token: i1.HttpClient }, { token: i2.ConfigService }], target: i0.ɵɵFactoryTarget.Injectable });
+VerzoekPluginService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: VerzoekPluginService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: VerzoekPluginService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: function () { return [{ type: i1.HttpClient }, { type: i2.ConfigService }]; } });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/plugins/verzoek/verzoek-plugin.module.mjs

@@ -0,0 +1,81 @@
+/*
+ * Copyright 2015-2023 Ritense BV, the Netherlands.
+ *
+ * Licensed under EUPL, Version 1.2 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { NgModule } from '@angular/core';
+import { VerzoekConfigurationComponent } from './components/verzoek-configuration/verzoek-configuration.component';
+import { PluginTranslatePipeModule } from '../../pipes';
+import { CommonModule } from '@angular/common';
+import { ButtonModule, FormModule, InputLabelModule, InputModule, MultiInputFormModule, ParagraphModule, RadioModule, SelectModule, TooltipIconModule, } from '@valtimo/user-interface';
+import { ButtonModule as CarbonButtonModule, InputModule as CarbonInputModule, ModalModule, } from 'carbon-components-angular';
+import { CarbonMultiInputModule } from '@valtimo/components';
+import * as i0 from "@angular/core";
+export class VerzoekPluginModule {
+}
+VerzoekPluginModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: VerzoekPluginModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+VerzoekPluginModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "14.2.12", ngImport: i0, type: VerzoekPluginModule, declarations: [VerzoekConfigurationComponent], imports: [CommonModule,
+        PluginTranslatePipeModule,
+        FormModule,
+        InputModule,
+        SelectModule,
+        ParagraphModule,
+        MultiInputFormModule,
+        RadioModule,
+        InputLabelModule,
+        ButtonModule,
+        ModalModule,
+        CarbonInputModule,
+        TooltipIconModule,
+        CarbonMultiInputModule,
+        CarbonButtonModule], exports: [VerzoekConfigurationComponent] });
+VerzoekPluginModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: VerzoekPluginModule, imports: [CommonModule,
+        PluginTranslatePipeModule,
+        FormModule,
+        InputModule,
+        SelectModule,
+        ParagraphModule,
+        MultiInputFormModule,
+        RadioModule,
+        InputLabelModule,
+        ButtonModule,
+        ModalModule,
+        CarbonInputModule,
+        TooltipIconModule,
+        CarbonMultiInputModule,
+        CarbonButtonModule] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: VerzoekPluginModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    declarations: [VerzoekConfigurationComponent],
+                    imports: [
+                        CommonModule,
+                        PluginTranslatePipeModule,
+                        FormModule,
+                        InputModule,
+                        SelectModule,
+                        ParagraphModule,
+                        MultiInputFormModule,
+                        RadioModule,
+                        InputLabelModule,
+                        ButtonModule,
+                        ModalModule,
+                        CarbonInputModule,
+                        TooltipIconModule,
+                        CarbonMultiInputModule,
+                        CarbonButtonModule,
+                    ],
+                    exports: [VerzoekConfigurationComponent],
+                }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/plugins/verzoek/verzoek-plugin.specification.mjs

@@ -0,0 +1,140 @@
+/*
+ * Copyright 2015-2023 Ritense BV, the Netherlands.
+ *
+ * Licensed under EUPL, Version 1.2 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { VerzoekConfigurationComponent } from './components/verzoek-configuration/verzoek-configuration.component';
+import { VERZOEK_PLUGIN_LOGO_BASE64 } from './assets/verzoek-plugin-logo';
+const verzoekPluginSpecification = {
+    pluginId: 'verzoek',
+    pluginConfigurationComponent: VerzoekConfigurationComponent,
+    pluginLogoBase64: VERZOEK_PLUGIN_LOGO_BASE64,
+    pluginTranslations: {
+        nl: {
+            title: 'Verzoek',
+            description: 'De Verzoek-plugin handelt aanvragen af en maakt een Zaakdossier aan. Een Verzoek is een Object in de Objecten API en wordt meestal met behulp van een portaal aangemaakt.',
+            configurationTitle: 'Configuratienaam',
+            configurationTitleTooltip: 'De naam van de huidige plugin-configuratie. Onder deze naam kan de configuratie in de rest van de applicatie teruggevonden worden.',
+            notificatiesApiPluginConfiguration: 'Notificaties API-configuratie',
+            objectManagementId: 'Object management-configuratie',
+            processToStart: 'Proces',
+            rsin: 'RSIN',
+            verzoekProperties: 'Verzoektypen',
+            type: 'Type',
+            caseDefinitionName: 'Dossierdefinitie',
+            initiatorRoltypeUrl: 'Roltype',
+            processDefinitionKey: 'Procesdefinitie',
+            initiatorRolDescription: 'Rolbeschrijving',
+            addVerzoekType: 'Verzoektype toevoegen',
+            verzoekPropertiesTooltip: 'De verzoektypen die aangemaakt worden wannneer er een notificatie binnenkomt.',
+            notificatiesApiPluginConfigurationTooltip: 'Configuratie van de Notificaties API die wordt gebruikt om te communiceren tussen GZAC en andere applicaties.',
+            objectManagementIdTooltip: 'Configuratie van het object dat wordt gebruikt om een verzoek op te slaan.',
+            processToStartTooltip: 'Het proces dat een zaak aanmaakt wanneer een notificatie binnenkomt.',
+            rsinTooltip: 'Dit nummer moet voldoen aan dezelfde specificaties als een BSN-nummer.',
+            typeTooltip: "Het type van het verzoek dat wordt gebruikt om het object te identificeren. Bv. 'verzoek'.",
+            caseDefinitionNameTooltip: 'Selecteer hier het dossiertype waarvan een instantie gestart moet worden wanneer er een verzoek binnenkomt.',
+            initiatorRoltypeUrlTooltip: 'Het roltype van de aanvrager die wordt opgeslagen wanneer er een verzoek binnenkomt.',
+            initiatorRolDescriptionTooltip: 'Een beschrijving van het roltype van de aanvrager die wordt opgeslagen wanneer er een verzoek binnenkomt.',
+            processDefinitionKeyTooltip: 'Selecteer hier het proces dat gestart moet worden wanneer het eerder geselecteerde systeemproces afgerond is.',
+            copyStrategy: 'Kopieerstrategie',
+            copyStrategyTooltip: 'Met deze optie wordt bepaald of het volledige Verzoek-object in het document terecht komt, of slechts de gespecifieerde velden.',
+            full: 'Volledig',
+            specified: 'Gespecifieerde velden',
+            mapping: 'Mapping',
+            setMapping: 'Mapping instellen',
+            mappingTooltip: "Stel hier de velden in die gekopieerd moeten worden van het Verzoek-object naar het document. Bijvoorbeeld: '/voorletters' -> 'doc:/voorletters-machtiginggever'.",
+            close: 'Sluiten',
+            save: 'Opslaan',
+            target: 'Bestemming',
+            source: 'Bron',
+        },
+        en: {
+            title: 'Verzoek',
+            description: 'The Verzoek plugin handles requests and creates a Zaakdossier. A Verzoek is an Object in the Objecten API and is usually created using a portal.',
+            configurationTitle: 'Configuration name',
+            configurationTitleTooltip: 'The name of the current plugin configuration. Under this name, the configuration can be found in the rest of the application.',
+            notificatiesApiPluginConfiguration: 'Notificaties API configuration',
+            objectManagementId: 'Object management configuration',
+            processToStart: 'Process',
+            rsin: 'RSIN',
+            verzoekProperties: 'Verzoek types',
+            type: 'Type',
+            caseDefinitionName: 'Case definition',
+            initiatorRoltypeUrl: 'Role type',
+            processDefinitionKey: 'Process definition',
+            initiatorRolDescription: 'Role description',
+            addVerzoekType: 'Add verzoek type',
+            verzoekPropertiesTooltip: 'The verzoek types that are created when a notification is received.',
+            notificatiesApiPluginConfigurationTooltip: 'Configuration of the Notificaties API used to communicate between GZAC and other applications.',
+            objectManagementIdTooltip: 'Configuration of the object used to store a verzoek.',
+            processToStartTooltip: 'The process that creates a case when a notification is received.',
+            rsinTooltip: 'This number must meet the same specifications as a BSN number.',
+            typeTooltip: "The type of verzoek used to identify the object. Eg. 'verzoek'.",
+            caseDefinitionNameTooltip: 'The case type of which an instance should be started when a verzoek comes in.',
+            initiatorRoltypeUrlTooltip: 'The role type of the requestor that is saved when a verzoek comes in.',
+            initiatorRolDescriptionTooltip: "A description of the requester's role type that is saved when a verzoek comes in.",
+            processDefinitionKeyTooltip: 'Select the process that should be started when the previously selected system process has finished.',
+            copyStrategy: 'Copy strategy',
+            copyStrategyTooltip: 'This option determines whether the entire Verzoek object is included in the document, or only the defined fields.',
+            full: 'Complete',
+            specified: 'Specified fields',
+            mapping: 'Mapping',
+            setMapping: 'Set mapping',
+            mappingTooltip: "Set the fields to be copied from the Verzoek object to the document. For example: '/voorletters' -> 'doc:/voorletters-machtiginggever'.",
+            close: 'Close',
+            save: 'Save',
+            target: 'Target',
+            source: 'Source',
+        },
+        de: {
+            title: 'Verzoek',
+            description: 'Das Verzoek-Plugin verarbeitet Anfragen und erstellt eine Zaakdossier. Eine Verzoek ist ein Object in der Objecten API und wird normalerweise mithilfe eines Portals erstellt.',
+            configurationTitle: 'Konfigurationsname',
+            configurationTitleTooltip: 'Der Name der aktuellen Plugin-Konfiguration. Unter diesem Namen ist die Konfiguration im Rest der Anwendung zu finden.',
+            notificatiesApiPluginConfiguration: 'Notificaties API-Konfiguration',
+            objectManagementId: 'Object management-Konfiguration',
+            processToStart: 'Prozess',
+            rsin: 'RSIN',
+            verzoekProperties: 'Verzoektypen',
+            type: 'Typ',
+            caseDefinitionName: 'Dateidefinition',
+            initiatorRoltypeUrl: 'Rollentyp',
+            processDefinitionKey: 'Prozessdefinition',
+            initiatorRolDescription: 'Rollenbeschreibung',
+            addVerzoekType: 'Verzoektyp hinzufügen',
+            verzoekPropertiesTooltip: 'Die Verzoektypen die erstellt werden wenn eine Benachrichtigung eintrifft.',
+            notificatiesApiPluginConfigurationTooltip: 'Konfiguration der Notificaties API, die für die Kommunikation zwischen GZAC und anderen Anwendungen verwendet wird.',
+            objectManagementIdTooltip: 'Konfiguration des Objects, das zum Speichern einer Verzoek verwendet wird.',
+            processToStartTooltip: 'Der Prozess, der einen Fall erstellt, wenn eine Benachrichtigung eintrifft.',
+            rsinTooltip: 'Diese Nummer muss die gleichen Spezifikationen wie eine BSN-Nummer erfüllen.',
+            typeTooltip: "Der Verzoektyp, der zum Identifizieren des Objects verwendet wird. Z.B. 'verzoek'.",
+            caseDefinitionNameTooltip: 'Wählen Sie hier den Falltyp aus, von dem eine Instanz gestartet werden soll, wenn eine Verzoek eintrifft.',
+            initiatorRoltypeUrlTooltip: 'Der Rollentyp des Anforderers, der gespeichert wird, wenn eine Verzoek eingeht.',
+            initiatorRolDescriptionTooltip: 'Eine Beschreibung des Rollentyps des Anforderers, die gespeichert wird, wenn eine Verzoek eingeht.',
+            processDefinitionKeyTooltip: 'Wählen Sie hier den Prozess aus, der gestartet werden soll, wenn der zuvor ausgewählte Systemprozess beendet ist.',
+            copyStrategy: 'Kopierstrategie',
+            copyStrategyTooltip: 'Diese Option legt fest, ob das gesamte Verzoek-Objekt in das Dokument aufgenommen wird oder nur die definierten Felder.',
+            full: 'Vollständig',
+            specified: 'Angegebene Felder',
+            mapping: 'Mapping',
+            setMapping: 'Mapping festlegen',
+            mappingTooltip: "Legen Sie hier die Felder fest, die vom Verzoek-Objekt in das Dokument kopiert werden sollen. Zum Beispiel: '/voorletters' -> 'doc:/voorletters-machtiginggever'.",
+            close: 'Schließen',
+            save: 'Speichern',
+            target: 'Ziel',
+            source: 'Ursprung',
+        },
+    },
+};
+export { verzoekPluginSpecification };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"verzoek-plugin.specification.js","sourceRoot":"","sources":["../../../../../../../projects/valtimo/plugin/src/lib/plugins/verzoek/verzoek-plugin.specification.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAGH,OAAO,EAAC,6BAA6B,EAAC,MAAM,oEAAoE,CAAC;AACjH,OAAO,EAAC,0BAA0B,EAAC,MAAM,8BAA8B,CAAC;AAExE,MAAM,0BAA0B,GAAwB;IACtD,QAAQ,EAAE,SAAS;IACnB,4BAA4B,EAAE,6BAA6B;IAC3D,gBAAgB,EAAE,0BAA0B;IAC5C,kBAAkB,EAAE;QAClB,EAAE,EAAE;YACF,KAAK,EAAE,SAAS;YAChB,WAAW,EACT,2KAA2K;YAC7K,kBAAkB,EAAE,kBAAkB;YACtC,yBAAyB,EACvB,oIAAoI;YACtI,kCAAkC,EAAE,+BAA+B;YACnE,kBAAkB,EAAE,gCAAgC;YACpD,cAAc,EAAE,QAAQ;YACxB,IAAI,EAAE,MAAM;YACZ,iBAAiB,EAAE,cAAc;YACjC,IAAI,EAAE,MAAM;YACZ,kBAAkB,EAAE,kBAAkB;YACtC,mBAAmB,EAAE,SAAS;YAC9B,oBAAoB,EAAE,iBAAiB;YACvC,uBAAuB,EAAE,iBAAiB;YAC1C,cAAc,EAAE,uBAAuB;YACvC,wBAAwB,EACtB,+EAA+E;YACjF,yCAAyC,EACvC,+GAA+G;YACjH,yBAAyB,EACvB,4EAA4E;YAC9E,qBAAqB,EAAE,sEAAsE;YAC7F,WAAW,EAAE,wEAAwE;YACrF,WAAW,EACT,4FAA4F;YAC9F,yBAAyB,EACvB,6GAA6G;YAC/G,0BAA0B,EACxB,sFAAsF;YACxF,8BAA8B,EAC5B,2GAA2G;YAC7G,2BAA2B,EACzB,+GAA+G;YACjH,YAAY,EAAE,kBAAkB;YAChC,mBAAmB,EACjB,iIAAiI;YACnI,IAAI,EAAE,UAAU;YAChB,SAAS,EAAE,uBAAuB;YAClC,OAAO,EAAE,SAAS;YAClB,UAAU,EAAE,mBAAmB;YAC/B,cAAc,EACZ,mKAAmK;YACrK,KAAK,EAAE,SAAS;YAChB,IAAI,EAAE,SAAS;YACf,MAAM,EAAE,YAAY;YACpB,MAAM,EAAE,MAAM;SACf;QACD,EAAE,EAAE;YACF,KAAK,EAAE,SAAS;YAChB,WAAW,EACT,kJAAkJ;YACpJ,kBAAkB,EAAE,oBAAoB;YACxC,yBAAyB,EACvB,+HAA+H;YACjI,kCAAkC,EAAE,gCAAgC;YACpE,kBAAkB,EAAE,iCAAiC;YACrD,cAAc,EAAE,SAAS;YACzB,IAAI,EAAE,MAAM;YACZ,iBAAiB,EAAE,eAAe;YAClC,IAAI,EAAE,MAAM;YACZ,kBAAkB,EAAE,iBAAiB;YACrC,mBAAmB,EAAE,WAAW;YAChC,oBAAoB,EAAE,oBAAoB;YAC1C,uBAAuB,EAAE,kBAAkB;YAC3C,cAAc,EAAE,kBAAkB;YAClC,wBAAwB,EACtB,qEAAqE;YACvE,yCAAyC,EACvC,gGAAgG;YAClG,yBAAyB,EAAE,sDAAsD;YACjF,qBAAqB,EAAE,kEAAkE;YACzF,WAAW,EAAE,gEAAgE;YAC7E,WAAW,EAAE,iEAAiE;YAC9E,yBAAyB,EACvB,+EAA+E;YACjF,0BAA0B,EACxB,uEAAuE;YACzE,8BAA8B,EAC5B,mFAAmF;YACrF,2BAA2B,EACzB,qGAAqG;YACvG,YAAY,EAAE,eAAe;YAC7B,mBAAmB,EACjB,mHAAmH;YACrH,IAAI,EAAE,UAAU;YAChB,SAAS,EAAE,kBAAkB;YAC7B,OAAO,EAAE,SAAS;YAClB,UAAU,EAAE,aAAa;YACzB,cAAc,EACZ,yIAAyI;YAC3I,KAAK,EAAE,OAAO;YACd,IAAI,EAAE,MAAM;YACZ,MAAM,EAAE,QAAQ;YAChB,MAAM,EAAE,QAAQ;SACjB;QACD,EAAE,EAAE;YACF,KAAK,EAAE,SAAS;YAChB,WAAW,EACT,gLAAgL;YAClL,kBAAkB,EAAE,oBAAoB;YACxC,yBAAyB,EACvB,wHAAwH;YAC1H,kCAAkC,EAAE,gCAAgC;YACpE,kBAAkB,EAAE,iCAAiC;YACrD,cAAc,EAAE,SAAS;YACzB,IAAI,EAAE,MAAM;YACZ,iBAAiB,EAAE,cAAc;YACjC,IAAI,EAAE,KAAK;YACX,kBAAkB,EAAE,iBAAiB;YACrC,mBAAmB,EAAE,WAAW;YAChC,oBAAoB,EAAE,mBAAmB;YACzC,uBAAuB,EAAE,oBAAoB;YAC7C,cAAc,EAAE,uBAAuB;YACvC,wBAAwB,EACtB,4EAA4E;YAC9E,yCAAyC,EACvC,qHAAqH;YACvH,yBAAyB,EACvB,4EAA4E;YAC9E,qBAAqB,EACnB,6EAA6E;YAC/E,WAAW,EAAE,8EAA8E;YAC3F,WAAW,EACT,oFAAoF;YACtF,yBAAyB,EACvB,2GAA2G;YAC7G,0BAA0B,EACxB,iFAAiF;YACnF,8BAA8B,EAC5B,oGAAoG;YACtG,2BAA2B,EACzB,mHAAmH;YACrH,YAAY,EAAE,iBAAiB;YAC/B,mBAAmB,EACjB,yHAAyH;YAC3H,IAAI,EAAE,aAAa;YACnB,SAAS,EAAE,mBAAmB;YAC9B,OAAO,EAAE,SAAS;YAClB,UAAU,EAAE,mBAAmB;YAC/B,cAAc,EACZ,mKAAmK;YACrK,KAAK,EAAE,WAAW;YAClB,IAAI,EAAE,WAAW;YACjB,MAAM,EAAE,MAAM;YACd,MAAM,EAAE,UAAU;SACnB;KACF;CACF,CAAC;AAEF,OAAO,EAAC,0BAA0B,EAAC,CAAC","sourcesContent":["/*\n * Copyright 2015-2023 Ritense BV, the Netherlands.\n *\n * Licensed under EUPL, Version 1.2 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" basis,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {PluginSpecification} from '../../models';\nimport {VerzoekConfigurationComponent} from './components/verzoek-configuration/verzoek-configuration.component';\nimport {VERZOEK_PLUGIN_LOGO_BASE64} from './assets/verzoek-plugin-logo';\n\nconst verzoekPluginSpecification: PluginSpecification = {\n  pluginId: 'verzoek',\n  pluginConfigurationComponent: VerzoekConfigurationComponent,\n  pluginLogoBase64: VERZOEK_PLUGIN_LOGO_BASE64,\n  pluginTranslations: {\n    nl: {\n      title: 'Verzoek',\n      description:\n        'De Verzoek-plugin handelt aanvragen af en maakt een Zaakdossier aan. Een Verzoek is een Object in de Objecten API en wordt meestal met behulp van een portaal aangemaakt.',\n      configurationTitle: 'Configuratienaam',\n      configurationTitleTooltip:\n        'De naam van de huidige plugin-configuratie. Onder deze naam kan de configuratie in de rest van de applicatie teruggevonden worden.',\n      notificatiesApiPluginConfiguration: 'Notificaties API-configuratie',\n      objectManagementId: 'Object management-configuratie',\n      processToStart: 'Proces',\n      rsin: 'RSIN',\n      verzoekProperties: 'Verzoektypen',\n      type: 'Type',\n      caseDefinitionName: 'Dossierdefinitie',\n      initiatorRoltypeUrl: 'Roltype',\n      processDefinitionKey: 'Procesdefinitie',\n      initiatorRolDescription: 'Rolbeschrijving',\n      addVerzoekType: 'Verzoektype toevoegen',\n      verzoekPropertiesTooltip:\n        'De verzoektypen die aangemaakt worden wannneer er een notificatie binnenkomt.',\n      notificatiesApiPluginConfigurationTooltip:\n        'Configuratie van de Notificaties API die wordt gebruikt om te communiceren tussen GZAC en andere applicaties.',\n      objectManagementIdTooltip:\n        'Configuratie van het object dat wordt gebruikt om een verzoek op te slaan.',\n      processToStartTooltip: 'Het proces dat een zaak aanmaakt wanneer een notificatie binnenkomt.',\n      rsinTooltip: 'Dit nummer moet voldoen aan dezelfde specificaties als een BSN-nummer.',\n      typeTooltip:\n        \"Het type van het verzoek dat wordt gebruikt om het object te identificeren. Bv. 'verzoek'.\",\n      caseDefinitionNameTooltip:\n        'Selecteer hier het dossiertype waarvan een instantie gestart moet worden wanneer er een verzoek binnenkomt.',\n      initiatorRoltypeUrlTooltip:\n        'Het roltype van de aanvrager die wordt opgeslagen wanneer er een verzoek binnenkomt.',\n      initiatorRolDescriptionTooltip:\n        'Een beschrijving van het roltype van de aanvrager die wordt opgeslagen wanneer er een verzoek binnenkomt.',\n      processDefinitionKeyTooltip:\n        'Selecteer hier het proces dat gestart moet worden wanneer het eerder geselecteerde systeemproces afgerond is.',\n      copyStrategy: 'Kopieerstrategie',\n      copyStrategyTooltip:\n        'Met deze optie wordt bepaald of het volledige Verzoek-object in het document terecht komt, of slechts de gespecifieerde velden.',\n      full: 'Volledig',\n      specified: 'Gespecifieerde velden',\n      mapping: 'Mapping',\n      setMapping: 'Mapping instellen',\n      mappingTooltip:\n        \"Stel hier de velden in die gekopieerd moeten worden van het Verzoek-object naar het document. Bijvoorbeeld: '/voorletters' -> 'doc:/voorletters-machtiginggever'.\",\n      close: 'Sluiten',\n      save: 'Opslaan',\n      target: 'Bestemming',\n      source: 'Bron',\n    },\n    en: {\n      title: 'Verzoek',\n      description:\n        'The Verzoek plugin handles requests and creates a Zaakdossier. A Verzoek is an Object in the Objecten API and is usually created using a portal.',\n      configurationTitle: 'Configuration name',\n      configurationTitleTooltip:\n        'The name of the current plugin configuration. Under this name, the configuration can be found in the rest of the application.',\n      notificatiesApiPluginConfiguration: 'Notificaties API configuration',\n      objectManagementId: 'Object management configuration',\n      processToStart: 'Process',\n      rsin: 'RSIN',\n      verzoekProperties: 'Verzoek types',\n      type: 'Type',\n      caseDefinitionName: 'Case definition',\n      initiatorRoltypeUrl: 'Role type',\n      processDefinitionKey: 'Process definition',\n      initiatorRolDescription: 'Role description',\n      addVerzoekType: 'Add verzoek type',\n      verzoekPropertiesTooltip:\n        'The verzoek types that are created when a notification is received.',\n      notificatiesApiPluginConfigurationTooltip:\n        'Configuration of the Notificaties API used to communicate between GZAC and other applications.',\n      objectManagementIdTooltip: 'Configuration of the object used to store a verzoek.',\n      processToStartTooltip: 'The process that creates a case when a notification is received.',\n      rsinTooltip: 'This number must meet the same specifications as a BSN number.',\n      typeTooltip: \"The type of verzoek used to identify the object. Eg. 'verzoek'.\",\n      caseDefinitionNameTooltip:\n        'The case type of which an instance should be started when a verzoek comes in.',\n      initiatorRoltypeUrlTooltip:\n        'The role type of the requestor that is saved when a verzoek comes in.',\n      initiatorRolDescriptionTooltip:\n        \"A description of the requester's role type that is saved when a verzoek comes in.\",\n      processDefinitionKeyTooltip:\n        'Select the process that should be started when the previously selected system process has finished.',\n      copyStrategy: 'Copy strategy',\n      copyStrategyTooltip:\n        'This option determines whether the entire Verzoek object is included in the document, or only the defined fields.',\n      full: 'Complete',\n      specified: 'Specified fields',\n      mapping: 'Mapping',\n      setMapping: 'Set mapping',\n      mappingTooltip:\n        \"Set the fields to be copied from the Verzoek object to the document. For example: '/voorletters' -> 'doc:/voorletters-machtiginggever'.\",\n      close: 'Close',\n      save: 'Save',\n      target: 'Target',\n      source: 'Source',\n    },\n    de: {\n      title: 'Verzoek',\n      description:\n        'Das Verzoek-Plugin verarbeitet Anfragen und erstellt eine Zaakdossier. Eine Verzoek ist ein Object in der Objecten API und wird normalerweise mithilfe eines Portals erstellt.',\n      configurationTitle: 'Konfigurationsname',\n      configurationTitleTooltip:\n        'Der Name der aktuellen Plugin-Konfiguration. Unter diesem Namen ist die Konfiguration im Rest der Anwendung zu finden.',\n      notificatiesApiPluginConfiguration: 'Notificaties API-Konfiguration',\n      objectManagementId: 'Object management-Konfiguration',\n      processToStart: 'Prozess',\n      rsin: 'RSIN',\n      verzoekProperties: 'Verzoektypen',\n      type: 'Typ',\n      caseDefinitionName: 'Dateidefinition',\n      initiatorRoltypeUrl: 'Rollentyp',\n      processDefinitionKey: 'Prozessdefinition',\n      initiatorRolDescription: 'Rollenbeschreibung',\n      addVerzoekType: 'Verzoektyp hinzufügen',\n      verzoekPropertiesTooltip:\n        'Die Verzoektypen die erstellt werden wenn eine Benachrichtigung eintrifft.',\n      notificatiesApiPluginConfigurationTooltip:\n        'Konfiguration der Notificaties API, die für die Kommunikation zwischen GZAC und anderen Anwendungen verwendet wird.',\n      objectManagementIdTooltip:\n        'Konfiguration des Objects, das zum Speichern einer Verzoek verwendet wird.',\n      processToStartTooltip:\n        'Der Prozess, der einen Fall erstellt, wenn eine Benachrichtigung eintrifft.',\n      rsinTooltip: 'Diese Nummer muss die gleichen Spezifikationen wie eine BSN-Nummer erfüllen.',\n      typeTooltip:\n        \"Der Verzoektyp, der zum Identifizieren des Objects verwendet wird. Z.B. 'verzoek'.\",\n      caseDefinitionNameTooltip:\n        'Wählen Sie hier den Falltyp aus, von dem eine Instanz gestartet werden soll, wenn eine Verzoek eintrifft.',\n      initiatorRoltypeUrlTooltip:\n        'Der Rollentyp des Anforderers, der gespeichert wird, wenn eine Verzoek eingeht.',\n      initiatorRolDescriptionTooltip:\n        'Eine Beschreibung des Rollentyps des Anforderers, die gespeichert wird, wenn eine Verzoek eingeht.',\n      processDefinitionKeyTooltip:\n        'Wählen Sie hier den Prozess aus, der gestartet werden soll, wenn der zuvor ausgewählte Systemprozess beendet ist.',\n      copyStrategy: 'Kopierstrategie',\n      copyStrategyTooltip:\n        'Diese Option legt fest, ob das gesamte Verzoek-Objekt in das Dokument aufgenommen wird oder nur die definierten Felder.',\n      full: 'Vollständig',\n      specified: 'Angegebene Felder',\n      mapping: 'Mapping',\n      setMapping: 'Mapping festlegen',\n      mappingTooltip:\n        \"Legen Sie hier die Felder fest, die vom Verzoek-Objekt in das Dokument kopiert werden sollen. Zum Beispiel: '/voorletters' -> 'doc:/voorletters-machtiginggever'.\",\n      close: 'Schließen',\n      save: 'Speichern',\n      target: 'Ziel',\n      source: 'Ursprung',\n    },\n  },\n};\n\nexport {verzoekPluginSpecification};\n"]}

package/esm2020/lib/plugins/zaken-api/assets/index.mjs

@@ -1,5 +1,5 @@
 /*
- * Copyright 2015-2020 Ritense BV, the Netherlands.
+ * Copyright 2015-2023 Ritense BV, the Netherlands.
  *
  * Licensed under EUPL, Version 1.2 (the "License");
  * you may not use this file except in compliance with the License.
@@ -14,4 +14,4 @@
  * limitations under the License.
  */
 export * from './zaken-api-plugin-logo';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy92YWx0aW1vL3BsdWdpbi9zcmMvbGliL3BsdWdpbnMvemFrZW4tYXBpL2Fzc2V0cy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7Ozs7Ozs7Ozs7R0FjRztBQUVILGNBQWMseUJBQXlCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKlxuICogQ29weXJpZ2h0IDIwMTUtMjAyMCBSaXRlbnNlIEJWLCB0aGUgTmV0aGVybGFuZHMuXG4gKlxuICogTGljZW5zZWQgdW5kZXIgRVVQTCwgVmVyc2lvbiAxLjIgKHRoZSBcIkxpY2Vuc2VcIik7XG4gKiB5b3UgbWF5IG5vdCB1c2UgdGhpcyBmaWxlIGV4Y2VwdCBpbiBjb21wbGlhbmNlIHdpdGggdGhlIExpY2Vuc2UuXG4gKiBZb3UgbWF5IG9idGFpbiBhIGNvcHkgb2YgdGhlIExpY2Vuc2UgYXRcbiAqXG4gKiBodHRwczovL2pvaW51cC5lYy5ldXJvcGEuZXUvY29sbGVjdGlvbi9ldXBsL2V1cGwtdGV4dC1ldXBsLTEyXG4gKlxuICogVW5sZXNzIHJlcXVpcmVkIGJ5IGFwcGxpY2FibGUgbGF3IG9yIGFncmVlZCB0byBpbiB3cml0aW5nLCBzb2Z0d2FyZVxuICogZGlzdHJpYnV0ZWQgdW5kZXIgdGhlIExpY2Vuc2UgaXMgZGlzdHJpYnV0ZWQgb24gYW4gXCJBUyBJU1wiIGJhc2lzLFxuICogV0lUSE9VVCBXQVJSQU5USUVTIE9SIENPTkRJVElPTlMgT0YgQU5ZIEtJTkQsIGVpdGhlciBleHByZXNzIG9yIGltcGxpZWQuXG4gKiBTZWUgdGhlIExpY2Vuc2UgZm9yIHRoZSBzcGVjaWZpYyBsYW5ndWFnZSBnb3Zlcm5pbmcgcGVybWlzc2lvbnMgYW5kXG4gKiBsaW1pdGF0aW9ucyB1bmRlciB0aGUgTGljZW5zZS5cbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL3pha2VuLWFwaS1wbHVnaW4tbG9nbyc7XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy92YWx0aW1vL3BsdWdpbi9zcmMvbGliL3BsdWdpbnMvemFrZW4tYXBpL2Fzc2V0cy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7Ozs7Ozs7Ozs7Ozs7R0FjRztBQUVILGNBQWMseUJBQXlCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKlxuICogQ29weXJpZ2h0IDIwMTUtMjAyMyBSaXRlbnNlIEJWLCB0aGUgTmV0aGVybGFuZHMuXG4gKlxuICogTGljZW5zZWQgdW5kZXIgRVVQTCwgVmVyc2lvbiAxLjIgKHRoZSBcIkxpY2Vuc2VcIik7XG4gKiB5b3UgbWF5IG5vdCB1c2UgdGhpcyBmaWxlIGV4Y2VwdCBpbiBjb21wbGlhbmNlIHdpdGggdGhlIExpY2Vuc2UuXG4gKiBZb3UgbWF5IG9idGFpbiBhIGNvcHkgb2YgdGhlIExpY2Vuc2UgYXRcbiAqXG4gKiBodHRwczovL2pvaW51cC5lYy5ldXJvcGEuZXUvY29sbGVjdGlvbi9ldXBsL2V1cGwtdGV4dC1ldXBsLTEyXG4gKlxuICogVW5sZXNzIHJlcXVpcmVkIGJ5IGFwcGxpY2FibGUgbGF3IG9yIGFncmVlZCB0byBpbiB3cml0aW5nLCBzb2Z0d2FyZVxuICogZGlzdHJpYnV0ZWQgdW5kZXIgdGhlIExpY2Vuc2UgaXMgZGlzdHJpYnV0ZWQgb24gYW4gXCJBUyBJU1wiIGJhc2lzLFxuICogV0lUSE9VVCBXQVJSQU5USUVTIE9SIENPTkRJVElPTlMgT0YgQU5ZIEtJTkQsIGVpdGhlciBleHByZXNzIG9yIGltcGxpZWQuXG4gKiBTZWUgdGhlIExpY2Vuc2UgZm9yIHRoZSBzcGVjaWZpYyBsYW5ndWFnZSBnb3Zlcm5pbmcgcGVybWlzc2lvbnMgYW5kXG4gKiBsaW1pdGF0aW9ucyB1bmRlciB0aGUgTGljZW5zZS5cbiAqL1xuXG5leHBvcnQgKiBmcm9tICcuL3pha2VuLWFwaS1wbHVnaW4tbG9nbyc7XG4iXX0=

package/esm2020/lib/plugins/zaken-api/assets/zaken-api-plugin-logo.mjs

@@ -1,5 +1,5 @@
 /*
- * Copyright 2015-2020 Ritense BV, the Netherlands.
+ * Copyright 2015-2023 Ritense BV, the Netherlands.
  *
  * Licensed under EUPL, Version 1.2 (the "License");
  * you may not use this file except in compliance with the License.
@@ -15,4 +15,4 @@
  */
 const ZAKEN_API_PLUGIN_LOGO_BASE64 = 'data:image/png;base64,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';
 export { ZAKEN_API_PLUGIN_LOGO_BASE64 };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"zaken-api-plugin-logo.js","sourceRoot":"","sources":["../../../../../../../../projects/valtimo/plugin/src/lib/plugins/zaken-api/assets/zaken-api-plugin-logo.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,MAAM,4BAA4B,GAChC,wpKAAwpK,CAAC;AAE3pK,OAAO,EAAC,4BAA4B,EAAC,CAAC","sourcesContent":["/*\n * Copyright 2015-2020 Ritense BV, the Netherlands.\n *\n * Licensed under EUPL, Version 1.2 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" basis,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nconst ZAKEN_API_PLUGIN_LOGO_BASE64 =\n  'data:image/png;base64,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';\n\nexport {ZAKEN_API_PLUGIN_LOGO_BASE64};\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"zaken-api-plugin-logo.js","sourceRoot":"","sources":["../../../../../../../../projects/valtimo/plugin/src/lib/plugins/zaken-api/assets/zaken-api-plugin-logo.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,MAAM,4BAA4B,GAChC,wpKAAwpK,CAAC;AAE3pK,OAAO,EAAC,4BAA4B,EAAC,CAAC","sourcesContent":["/*\n * Copyright 2015-2023 Ritense BV, the Netherlands.\n *\n * Licensed under EUPL, Version 1.2 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" basis,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nconst ZAKEN_API_PLUGIN_LOGO_BASE64 =\n  'data:image/png;base64,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';\n\nexport {ZAKEN_API_PLUGIN_LOGO_BASE64};\n"]}

package/esm2020/lib/plugins/zaken-api/components/create-natuurlijk-persoon-zaak-rol/create-natuurlijk-persoon-zaak-rol.component.mjs

@@ -0,0 +1,74 @@
+/*
+ * Copyright 2015-2023 Ritense BV, the Netherlands.
+ *
+ * Licensed under EUPL, Version 1.2 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" basis,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { Component, EventEmitter, Input, Output } from '@angular/core';
+import { BehaviorSubject, combineLatest, take } from 'rxjs';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common";
+import * as i2 from "@valtimo/user-interface";
+import * as i3 from "../../../../pipes/plugin-translate/plugin-translate.pipe";
+export class CreateNatuurlijkPersoonZaakRolComponent {
+    constructor() {
+        this.valid = new EventEmitter();
+        this.configuration = new EventEmitter();
+        this.formValue$ = new BehaviorSubject(null);
+        this.valid$ = new BehaviorSubject(false);
+    }
+    ngOnInit() {
+        this.openSaveSubscription();
+    }
+    ngOnDestroy() {
+        this.saveSubscription?.unsubscribe();
+    }
+    formValueChange(formValue) {
+        this.formValue$.next(formValue);
+        this.handleValid(formValue);
+    }
+    handleValid(formValue) {
+        const valid = !!(formValue.rolToelichting && formValue.roltypeUrl);
+        this.valid$.next(valid);
+        this.valid.emit(valid);
+    }
+    openSaveSubscription() {
+        this.saveSubscription = this.save$?.subscribe(save => {
+            combineLatest([this.formValue$, this.valid$])
+                .pipe(take(1))
+                .subscribe(([formValue, valid]) => {
+                if (valid) {
+                    this.configuration.emit(formValue);
+                }
+            });
+        });
+    }
+}
+CreateNatuurlijkPersoonZaakRolComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: CreateNatuurlijkPersoonZaakRolComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+CreateNatuurlijkPersoonZaakRolComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "14.2.12", type: CreateNatuurlijkPersoonZaakRolComponent, selector: "valtimo-create-natuurlijk-persoon-zaak-rol-configuration", inputs: { save$: "save$", disabled$: "disabled$", pluginId: "pluginId", prefillConfiguration$: "prefillConfiguration$" }, outputs: { valid: "valid", configuration: "configuration" }, ngImport: i0, template: "<!--\n  ~ Copyright 2015-2023 Ritense BV, the Netherlands.\n  ~\n  ~ Licensed under EUPL, Version 1.2 (the \"License\");\n  ~ you may not use this file except in compliance with the License.\n  ~ You may obtain a copy of the License at\n  ~\n  ~ https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12\n  ~\n  ~ Unless required by applicable law or agreed to in writing, software\n  ~ distributed under the License is distributed on an \"AS IS\" basis,\n  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n  ~ See the License for the specific language governing permissions and\n  ~ limitations under the License.\n  -->\n\n<v-form\n  (valueChange)=\"formValueChange($event)\"\n  *ngIf=\"{\n    disabled: disabled$ | async,\n    prefill: prefillConfiguration$ ? (prefillConfiguration$ | async) : null\n  } as obs\"\n>\n  <v-input\n    name=\"roltypeUrl\"\n    [title]=\"'roltypeUrl' | pluginTranslate : pluginId | async\"\n    [margin]=\"true\"\n    [defaultValue]=\"obs.prefill?.roltypeUrl\"\n    [disabled]=\"obs.disabled\"\n    [required]=\"true\"\n    [tooltip]=\"'roltypeUrlTooltip' | pluginTranslate : pluginId | async\"\n    [fullWidth]=\"true\"\n  >\n  </v-input>\n  <v-input\n    name=\"rolToelichting\"\n    [title]=\"'rolToelichting' | pluginTranslate : pluginId | async\"\n    [margin]=\"true\"\n    [defaultValue]=\"obs.prefill?.rolToelichting\"\n    [disabled]=\"obs.disabled\"\n    [required]=\"true\"\n    [tooltip]=\"'rolToelichtingTooltip' | pluginTranslate : pluginId | async\"\n    [fullWidth]=\"true\"\n  >\n  </v-input>\n  <v-input\n    name=\"inpBsn\"\n    [title]=\"'inpBsn' | pluginTranslate : pluginId | async\"\n    [margin]=\"true\"\n    [defaultValue]=\"obs.prefill?.inpBsn\"\n    [disabled]=\"obs.disabled\"\n    [required]=\"false\"\n    [tooltip]=\"'inpBsnTooltip' | pluginTranslate : pluginId | async\"\n    [fullWidth]=\"true\"\n  >\n  </v-input>\n  <v-input\n    name=\"anpIdentificatie\"\n    [title]=\"'anpIdentificatie' | pluginTranslate : pluginId | async\"\n    [margin]=\"true\"\n    [defaultValue]=\"obs.prefill?.anpIdentificatie\"\n    [disabled]=\"obs.disabled\"\n    [required]=\"false\"\n    [tooltip]=\"'anpIdentificatieTooltip' | pluginTranslate : pluginId | async\"\n    [fullWidth]=\"true\"\n  >\n  </v-input>\n  <v-input\n    name=\"inpA_nummer\"\n    [title]=\"'inpA_nummer' | pluginTranslate : pluginId | async\"\n    [margin]=\"true\"\n    [defaultValue]=\"obs.prefill?.inpA_nummer\"\n    [disabled]=\"obs.disabled\"\n    [required]=\"false\"\n    [tooltip]=\"'inpA_nummerTooltip' | pluginTranslate : pluginId | async\"\n    [fullWidth]=\"true\"\n  >\n  </v-input>\n</v-form>\n", styles: ["/*!\n * Copyright 2015-2023 Ritense BV, the Netherlands.\n *\n * Licensed under EUPL, Version 1.2 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" basis,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n"], dependencies: [{ kind: "directive", type: i1.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "component", type: i2.FormComponent, selector: "v-form", inputs: ["className"], outputs: ["valueChange"] }, { kind: "component", type: i2.InputComponent, selector: "v-input", inputs: ["name", "type", "title", "titleTranslationKey", "defaultValue", "widthPx", "fullWidth", "margin", "smallMargin", "disabled", "step", "min", "maxLength", "tooltip", "required", "hideNumberSpinBox", "smallLabel", "rows", "clear$"], outputs: ["valueChange"] }, { kind: "pipe", type: i1.AsyncPipe, name: "async" }, { kind: "pipe", type: i3.PluginTranslatePipe, name: "pluginTranslate" }] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "14.2.12", ngImport: i0, type: CreateNatuurlijkPersoonZaakRolComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'valtimo-create-natuurlijk-persoon-zaak-rol-configuration', template: "<!--\n  ~ Copyright 2015-2023 Ritense BV, the Netherlands.\n  ~\n  ~ Licensed under EUPL, Version 1.2 (the \"License\");\n  ~ you may not use this file except in compliance with the License.\n  ~ You may obtain a copy of the License at\n  ~\n  ~ https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12\n  ~\n  ~ Unless required by applicable law or agreed to in writing, software\n  ~ distributed under the License is distributed on an \"AS IS\" basis,\n  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n  ~ See the License for the specific language governing permissions and\n  ~ limitations under the License.\n  -->\n\n<v-form\n  (valueChange)=\"formValueChange($event)\"\n  *ngIf=\"{\n    disabled: disabled$ | async,\n    prefill: prefillConfiguration$ ? (prefillConfiguration$ | async) : null\n  } as obs\"\n>\n  <v-input\n    name=\"roltypeUrl\"\n    [title]=\"'roltypeUrl' | pluginTranslate : pluginId | async\"\n    [margin]=\"true\"\n    [defaultValue]=\"obs.prefill?.roltypeUrl\"\n    [disabled]=\"obs.disabled\"\n    [required]=\"true\"\n    [tooltip]=\"'roltypeUrlTooltip' | pluginTranslate : pluginId | async\"\n    [fullWidth]=\"true\"\n  >\n  </v-input>\n  <v-input\n    name=\"rolToelichting\"\n    [title]=\"'rolToelichting' | pluginTranslate : pluginId | async\"\n    [margin]=\"true\"\n    [defaultValue]=\"obs.prefill?.rolToelichting\"\n    [disabled]=\"obs.disabled\"\n    [required]=\"true\"\n    [tooltip]=\"'rolToelichtingTooltip' | pluginTranslate : pluginId | async\"\n    [fullWidth]=\"true\"\n  >\n  </v-input>\n  <v-input\n    name=\"inpBsn\"\n    [title]=\"'inpBsn' | pluginTranslate : pluginId | async\"\n    [margin]=\"true\"\n    [defaultValue]=\"obs.prefill?.inpBsn\"\n    [disabled]=\"obs.disabled\"\n    [required]=\"false\"\n    [tooltip]=\"'inpBsnTooltip' | pluginTranslate : pluginId | async\"\n    [fullWidth]=\"true\"\n  >\n  </v-input>\n  <v-input\n    name=\"anpIdentificatie\"\n    [title]=\"'anpIdentificatie' | pluginTranslate : pluginId | async\"\n    [margin]=\"true\"\n    [defaultValue]=\"obs.prefill?.anpIdentificatie\"\n    [disabled]=\"obs.disabled\"\n    [required]=\"false\"\n    [tooltip]=\"'anpIdentificatieTooltip' | pluginTranslate : pluginId | async\"\n    [fullWidth]=\"true\"\n  >\n  </v-input>\n  <v-input\n    name=\"inpA_nummer\"\n    [title]=\"'inpA_nummer' | pluginTranslate : pluginId | async\"\n    [margin]=\"true\"\n    [defaultValue]=\"obs.prefill?.inpA_nummer\"\n    [disabled]=\"obs.disabled\"\n    [required]=\"false\"\n    [tooltip]=\"'inpA_nummerTooltip' | pluginTranslate : pluginId | async\"\n    [fullWidth]=\"true\"\n  >\n  </v-input>\n</v-form>\n", styles: ["/*!\n * Copyright 2015-2023 Ritense BV, the Netherlands.\n *\n * Licensed under EUPL, Version 1.2 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" basis,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n"] }]
+        }], propDecorators: { save$: [{
+                type: Input
+            }], disabled$: [{
+                type: Input
+            }], pluginId: [{
+                type: Input
+            }], prefillConfiguration$: [{
+                type: Input
+            }], valid: [{
+                type: Output
+            }], configuration: [{
+                type: Output
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"create-natuurlijk-persoon-zaak-rol.component.js","sourceRoot":"","sources":["../../../../../../../../../projects/valtimo/plugin/src/lib/plugins/zaken-api/components/create-natuurlijk-persoon-zaak-rol/create-natuurlijk-persoon-zaak-rol.component.ts","../../../../../../../../../projects/valtimo/plugin/src/lib/plugins/zaken-api/components/create-natuurlijk-persoon-zaak-rol/create-natuurlijk-persoon-zaak-rol.component.html"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EAAC,SAAS,EAAE,YAAY,EAAE,KAAK,EAAqB,MAAM,EAAC,MAAM,eAAe,CAAC;AAExF,OAAO,EAAC,eAAe,EAAE,aAAa,EAA4B,IAAI,EAAC,MAAM,MAAM,CAAC;;;;;AAQpF,MAAM,OAAO,uCAAuC;IALpD;QAYY,UAAK,GAA0B,IAAI,YAAY,EAAW,CAAC;QAC3D,kBAAa,GACrB,IAAI,YAAY,EAAyC,CAAC;QAI3C,eAAU,GAAG,IAAI,eAAe,CAC/C,IAAI,CACL,CAAC;QACe,WAAM,GAAG,IAAI,eAAe,CAAU,KAAK,CAAC,CAAC;KAiC/D;IA/BC,QAAQ;QACN,IAAI,CAAC,oBAAoB,EAAE,CAAC;IAC9B,CAAC;IAED,WAAW;QACT,IAAI,CAAC,gBAAgB,EAAE,WAAW,EAAE,CAAC;IACvC,CAAC;IAED,eAAe,CAAC,SAAgD;QAC9D,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;QAChC,IAAI,CAAC,WAAW,CAAC,SAAS,CAAC,CAAC;IAC9B,CAAC;IAEO,WAAW,CAAC,SAAgD;QAClE,MAAM,KAAK,GAAG,CAAC,CAAC,CAAC,SAAS,CAAC,cAAc,IAAI,SAAS,CAAC,UAAU,CAAC,CAAC;QAEnE,IAAI,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;QACxB,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;IACzB,CAAC;IAEO,oBAAoB;QAC1B,IAAI,CAAC,gBAAgB,GAAG,IAAI,CAAC,KAAK,EAAE,SAAS,CAAC,IAAI,CAAC,EAAE;YACnD,aAAa,CAAC,CAAC,IAAI,CAAC,UAAU,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC;iBAC1C,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;iBACb,SAAS,CAAC,CAAC,CAAC,SAAS,EAAE,KAAK,CAAC,EAAE,EAAE;gBAChC,IAAI,KAAK,EAAE;oBACT,IAAI,CAAC,aAAa,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;iBACpC;YACH,CAAC,CAAC,CAAC;QACP,CAAC,CAAC,CAAC;IACL,CAAC;;qIAhDU,uCAAuC;yHAAvC,uCAAuC,uRC1BpD,ymFA+EA;4FDrDa,uCAAuC;kBALnD,SAAS;+BACE,0DAA0D;8BAO3D,KAAK;sBAAb,KAAK;gBACG,SAAS;sBAAjB,KAAK;gBACG,QAAQ;sBAAhB,KAAK;gBACG,qBAAqB;sBAA7B,KAAK;gBACI,KAAK;sBAAd,MAAM;gBACG,aAAa;sBAAtB,MAAM","sourcesContent":["/*\n * Copyright 2015-2023 Ritense BV, the Netherlands.\n *\n * Licensed under EUPL, Version 1.2 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" basis,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport {Component, EventEmitter, Input, OnDestroy, OnInit, Output} from '@angular/core';\nimport {FunctionConfigurationComponent} from '../../../../models';\nimport {BehaviorSubject, combineLatest, Observable, Subscription, take} from 'rxjs';\nimport {CreateNatuurlijkePersoonZaakRolConfig} from '../../models';\n\n@Component({\n  selector: 'valtimo-create-natuurlijk-persoon-zaak-rol-configuration',\n  templateUrl: './create-natuurlijk-persoon-zaak-rol.component.html',\n  styleUrls: ['./create-natuurlijk-persoon-zaak-rol.component.scss'],\n})\nexport class CreateNatuurlijkPersoonZaakRolComponent\n  implements FunctionConfigurationComponent, OnInit, OnDestroy\n{\n  @Input() save$: Observable<void>;\n  @Input() disabled$: Observable<boolean>;\n  @Input() pluginId: string;\n  @Input() prefillConfiguration$: Observable<CreateNatuurlijkePersoonZaakRolConfig>;\n  @Output() valid: EventEmitter<boolean> = new EventEmitter<boolean>();\n  @Output() configuration: EventEmitter<CreateNatuurlijkePersoonZaakRolConfig> =\n    new EventEmitter<CreateNatuurlijkePersoonZaakRolConfig>();\n\n  private saveSubscription!: Subscription;\n\n  private readonly formValue$ = new BehaviorSubject<CreateNatuurlijkePersoonZaakRolConfig | null>(\n    null\n  );\n  private readonly valid$ = new BehaviorSubject<boolean>(false);\n\n  ngOnInit(): void {\n    this.openSaveSubscription();\n  }\n\n  ngOnDestroy() {\n    this.saveSubscription?.unsubscribe();\n  }\n\n  formValueChange(formValue: CreateNatuurlijkePersoonZaakRolConfig): void {\n    this.formValue$.next(formValue);\n    this.handleValid(formValue);\n  }\n\n  private handleValid(formValue: CreateNatuurlijkePersoonZaakRolConfig): void {\n    const valid = !!(formValue.rolToelichting && formValue.roltypeUrl);\n\n    this.valid$.next(valid);\n    this.valid.emit(valid);\n  }\n\n  private openSaveSubscription(): void {\n    this.saveSubscription = this.save$?.subscribe(save => {\n      combineLatest([this.formValue$, this.valid$])\n        .pipe(take(1))\n        .subscribe(([formValue, valid]) => {\n          if (valid) {\n            this.configuration.emit(formValue);\n          }\n        });\n    });\n  }\n}\n","<!--\n  ~ Copyright 2015-2023 Ritense BV, the Netherlands.\n  ~\n  ~ Licensed under EUPL, Version 1.2 (the \"License\");\n  ~ you may not use this file except in compliance with the License.\n  ~ You may obtain a copy of the License at\n  ~\n  ~ https://joinup.ec.europa.eu/collection/eupl/eupl-text-eupl-12\n  ~\n  ~ Unless required by applicable law or agreed to in writing, software\n  ~ distributed under the License is distributed on an \"AS IS\" basis,\n  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n  ~ See the License for the specific language governing permissions and\n  ~ limitations under the License.\n  -->\n\n<v-form\n  (valueChange)=\"formValueChange($event)\"\n  *ngIf=\"{\n    disabled: disabled$ | async,\n    prefill: prefillConfiguration$ ? (prefillConfiguration$ | async) : null\n  } as obs\"\n>\n  <v-input\n    name=\"roltypeUrl\"\n    [title]=\"'roltypeUrl' | pluginTranslate : pluginId | async\"\n    [margin]=\"true\"\n    [defaultValue]=\"obs.prefill?.roltypeUrl\"\n    [disabled]=\"obs.disabled\"\n    [required]=\"true\"\n    [tooltip]=\"'roltypeUrlTooltip' | pluginTranslate : pluginId | async\"\n    [fullWidth]=\"true\"\n  >\n  </v-input>\n  <v-input\n    name=\"rolToelichting\"\n    [title]=\"'rolToelichting' | pluginTranslate : pluginId | async\"\n    [margin]=\"true\"\n    [defaultValue]=\"obs.prefill?.rolToelichting\"\n    [disabled]=\"obs.disabled\"\n    [required]=\"true\"\n    [tooltip]=\"'rolToelichtingTooltip' | pluginTranslate : pluginId | async\"\n    [fullWidth]=\"true\"\n  >\n  </v-input>\n  <v-input\n    name=\"inpBsn\"\n    [title]=\"'inpBsn' | pluginTranslate : pluginId | async\"\n    [margin]=\"true\"\n    [defaultValue]=\"obs.prefill?.inpBsn\"\n    [disabled]=\"obs.disabled\"\n    [required]=\"false\"\n    [tooltip]=\"'inpBsnTooltip' | pluginTranslate : pluginId | async\"\n    [fullWidth]=\"true\"\n  >\n  </v-input>\n  <v-input\n    name=\"anpIdentificatie\"\n    [title]=\"'anpIdentificatie' | pluginTranslate : pluginId | async\"\n    [margin]=\"true\"\n    [defaultValue]=\"obs.prefill?.anpIdentificatie\"\n    [disabled]=\"obs.disabled\"\n    [required]=\"false\"\n    [tooltip]=\"'anpIdentificatieTooltip' | pluginTranslate : pluginId | async\"\n    [fullWidth]=\"true\"\n  >\n  </v-input>\n  <v-input\n    name=\"inpA_nummer\"\n    [title]=\"'inpA_nummer' | pluginTranslate : pluginId | async\"\n    [margin]=\"true\"\n    [defaultValue]=\"obs.prefill?.inpA_nummer\"\n    [disabled]=\"obs.disabled\"\n    [required]=\"false\"\n    [tooltip]=\"'inpA_nummerTooltip' | pluginTranslate : pluginId | async\"\n    [fullWidth]=\"true\"\n  >\n  </v-input>\n</v-form>\n"]}