@lblod/ember-rdfa-editor-lblod-plugins 0.4.1 → 1.0.0-alpha.2

package/addon/services/roadsign-registry.ts

@@ -0,0 +1,288 @@
+import Service from '@ember/service';
+import { task, timeout } from 'ember-concurrency';
+import { tracked } from '@glimmer/tracking';
+import { getOwner } from '@ember/application';
+import { generateMeasuresQuery } from '../plugins/roadsign-regulation-plugin/utils/fetchData';
+import Instruction from '../models/instruction';
+import Measure from '../models/measure';
+import Sign from '../models/sign';
+import { IBindings } from 'fetch-sparql-endpoint';
+import { optionMapOr, unwrap } from '@lblod/ember-rdfa-editor/utils/option';
+import dataFactory from '@rdfjs/data-model';
+
+const PREFIXES = `
+PREFIX ex: <http://example.org#>
+PREFIX lblodMobiliteit: <http://data.lblod.info/vocabularies/mobiliteit/>
+PREFIX ext: <http://mu.semte.ch/vocabularies/ext/>
+PREFIX sh: <http://www.w3.org/ns/shacl#>
+PREFIX oslo: <http://data.vlaanderen.be/ns#>
+PREFIX skos: <http://www.w3.org/2004/02/skos/core#>
+PREFIX org: <http://www.w3.org/ns/org#>
+PREFIX mobiliteit: <https://data.vlaanderen.be/ns/mobiliteit#>
+`;
+
+const DEBOUNCE_MS = 100;
+
+export default class RoadsignRegistryService extends Service {
+  @tracked classifications: { value: string; label: string }[] = [];
+  instructions: Map<string, Instruction[]> = new Map();
+  endpoint: string;
+  imageBaseUrl: string;
+
+  constructor() {
+    // eslint-disable-next-line prefer-rest-params
+    super(...arguments);
+    const config = getOwner(this).resolveRegistration('config:environment') as {
+      roadsignRegulationPlugin: {
+        imageBaseUrl: string;
+        endpoint: string;
+      };
+    };
+    this.imageBaseUrl = config.roadsignRegulationPlugin.imageBaseUrl;
+    this.endpoint = config.roadsignRegulationPlugin.endpoint;
+    void this.loadClassifications.perform();
+  }
+
+  loadClassifications = task(async () => {
+    const result = await this.executeQuery.perform(`
+    SELECT DISTINCT ?classificationUri ?classificationLabel  WHERE {
+      ?measure ext:relation/ext:concept ?signUri.
+      ?signUri org:classification ?classificationUri.
+      ?classificationUri a mobiliteit:Verkeersbordcategorie;
+        skos:prefLabel ?classificationLabel.
+    }
+`);
+    const bindings = result.results.bindings;
+    this.classifications = bindings.map((binding) => ({
+      value: unwrap(binding['classificationUri']?.value),
+      label: unwrap(binding['classificationLabel']?.value),
+    }));
+  });
+
+  getInstructionsForMeasure = task(
+    async (uri: string): Promise<Instruction[]> => {
+      if (this.instructions.has(uri)) {
+        return unwrap(this.instructions.get(uri));
+      } else {
+        const instructions = await this.fetchInstructionsForMeasure.perform(
+          uri
+        );
+        this.instructions.set(uri, instructions);
+        return instructions;
+      }
+    }
+  );
+
+  searchCode = task(
+    { restartable: true },
+    async (
+      codeString?: string,
+      category?: string,
+      type?: string,
+      combinedSigns?: string[]
+    ) => {
+      await timeout(DEBOUNCE_MS);
+      if (!Array.isArray(combinedSigns)) {
+        if (combinedSigns) combinedSigns = [combinedSigns];
+        else combinedSigns = [];
+      }
+      let signFilter = '';
+      if (combinedSigns.length > 0) {
+        signFilter = combinedSigns
+          .map((sign) => `?measure ext:relation/ext:concept <${sign}>.`)
+          .join('\n');
+        signFilter += '\n';
+        const commaSeperatedSigns = combinedSigns
+          .map((sign) => `<${sign}>`)
+          .join(',');
+        signFilter += `FILTER (?signUri NOT IN (${commaSeperatedSigns}))`;
+      }
+
+      const query = `
+      SELECT DISTINCT ?signUri ?signCode WHERE {
+        ?measure ext:relation/ext:concept ?signUri.
+        ?signUri a ${type ? `<${type}>` : '?signType'};
+          skos:prefLabel ?signCode;
+          ext:valid "true"^^<http://mu.semte.ch/vocabularies/typed-literals/boolean>.
+        ${category ? `?signUri org:classification <${category}>` : ''}
+        ${
+          type
+            ? ''
+            : `
+          VALUES ?signType {
+            <https://data.vlaanderen.be/ns/mobiliteit#Verkeersbordconcept>
+            <https://data.vlaanderen.be/ns/mobiliteit#Wegmarkeringconcept>
+            <https://data.vlaanderen.be/ns/mobiliteit#Verkeerslichtconcept>
+          }
+        `
+        }
+        ${signFilter}
+        ${
+          codeString
+            ? `FILTER(CONTAINS(LCASE(?signCode), "${codeString.toLowerCase()}"))`
+            : ''
+        }
+      }
+      ORDER BY ASC(?signCode)
+    `;
+      const result = await this.executeQuery.perform(query);
+      const codes = result.results.bindings.map((binding) => ({
+        value: unwrap(binding['signUri']?.value),
+        label: unwrap(binding['signCode']?.value),
+      }));
+      return codes;
+    }
+  );
+
+  executeQuery = task(
+    async (
+      query: string
+    ): Promise<{
+      results: {
+        bindings: IBindings[];
+      };
+    }> => {
+      const encodedQuery = encodeURIComponent(`${PREFIXES}\n${query.trim()}`);
+      const response = await fetch(this.endpoint, {
+        method: 'POST',
+        mode: 'cors',
+        headers: {
+          Accept: 'application/sparql-results+json',
+          'Content-Type': 'application/x-www-form-urlencoded; charset=UTF-8',
+        },
+        body: `query=${encodedQuery}`,
+      });
+      if (response.ok) {
+        return response.json() as unknown as {
+          results: {
+            bindings: IBindings[];
+          };
+        };
+      } else {
+        throw new Error(
+          `Request to MOW backend was unsuccessful: [${response.status}] ${response.statusText}`
+        );
+      }
+    }
+  );
+
+  fetchInstructionsForMeasure = task(
+    async (uri: string): Promise<Instruction[]> => {
+      const query = `SELECT ?name ?template ?annotatedTemplate
+           WHERE {
+            <${uri}> ext:template/ext:mapping ?mapping.
+          ?mapping ext:variableType 'instruction';
+            ext:variable ?name;
+            ext:instructionVariable ?instructionVariable.
+          ?instructionVariable ext:annotated ?annotatedTemplate;
+            ext:value ?template.
+          }
+          `;
+      const result = await this.executeQuery.perform(query);
+      const instructions = result.results.bindings.map((binding) =>
+        Instruction.fromBinding(binding)
+      );
+      return instructions;
+    }
+  );
+
+  fetchMeasures = task(
+    { restartable: true },
+    async ({
+      zonality,
+      type,
+      codes,
+      category,
+      pageStart,
+    }: {
+      zonality?: string;
+      type?: string;
+      codes?: string[];
+      category?: string;
+      pageStart?: number;
+    } = {}) => {
+      const selectQuery = generateMeasuresQuery({
+        zonality,
+        type,
+        codes,
+        category,
+        pageStart,
+      });
+      const countQuery = generateMeasuresQuery({
+        zonality,
+        type,
+        codes,
+        category,
+        count: true,
+      });
+      const countResult = await this.executeQuery.perform(countQuery);
+
+      const count = optionMapOr(
+        0,
+        parseInt,
+        countResult.results.bindings[0]?.['count']?.value
+      );
+      const measures = [];
+      const result = await this.executeQuery.perform(selectQuery);
+      for (const binding of result.results.bindings) {
+        const measure = Measure.fromBinding(binding);
+        measure.signs = await this.fetchSignsForMeasure.perform(measure.uri);
+        measure.classifications = makeClassificationSet(measure.signs);
+        measures.push(measure);
+      }
+      return { measures, count };
+    }
+  );
+
+  fetchSignsForMeasure = task(async (uri: string) => {
+    const query = `
+SELECT ?uri ?code ?image ?zonality ?order (GROUP_CONCAT(?classification; SEPARATOR="|") AS ?classifications)
+WHERE {
+  <${uri}> ext:relation ?relation.
+  ?relation a ext:MustUseRelation;
+            <http://purl.org/linked-data/cube#order> ?order;
+            ext:concept ?uri.
+  ?uri a ?type;
+        skos:prefLabel ?code;
+        ext:zonality ?zonality;
+        mobiliteit:grafischeWeergave ?image.
+  OPTIONAL {
+    ?uri org:classification/skos:prefLabel ?classification.
+  }
+  } ORDER BY ASC(?order)
+`;
+    const result = await this.executeQuery.perform(query);
+    const signs = [];
+    for (const binding of result.results.bindings) {
+      const sign = Sign.fromBinding({
+        ...binding,
+        imageBaseUrl: dataFactory.namedNode(this.imageBaseUrl),
+      });
+      signs.push(sign);
+    }
+    return signs;
+  });
+}
+
+function makeClassificationSet(signs: Iterable<Sign>) {
+  const classifications = new Set();
+  for (const sign of signs) {
+    for (const c of sign.classifications) {
+      classifications.add(c);
+    }
+  }
+  sortSet(classifications);
+  return classifications;
+}
+
+function sortSet<T>(set: Set<T>) {
+  const entries = [];
+  for (const member of set) {
+    entries.push(member);
+  }
+  set.clear();
+  for (const entry of entries.sort()) {
+    set.add(entry);
+  }
+  return set;
+}

package/addon/services/{standard-template-plugin.js → standard-template-plugin.ts}

@@ -1,21 +1,27 @@
+import Store from '@ember-data/store';
+// eslint-disable-next-line ember/use-ember-data-rfc-395-imports
+import { DS } from 'ember-data';
 import Service, { inject as service } from '@ember/service';
-import { task, waitForProperty } from 'ember-concurrency';
+import { task, waitForProperty, Task } from 'ember-concurrency';
 import { tracked } from '@glimmer/tracking';
+import TemplateModel from '../models/template';
 
-export default class RdfaEditorStandardTemplatePluginService extends Service {
-  @service store;
-  @tracked templates;
+export default class StandardTemplatePluginService extends Service {
+  @service declare store: Store;
+  @tracked declare templates: DS.RecordArray<TemplateModel>;
 
   constructor() {
+    // eslint-disable-next-line prefer-rest-params
     super(...arguments);
-    this.loadTemplates();
+    void this.loadTemplates();
   }
 
-  @task
-  *fetchTemplates() {
-    yield waitForProperty(this, 'templates');
+  fetchTemplates: Task<DS.RecordArray<TemplateModel>, []> = task(async () => {
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore
+    await waitForProperty(this, 'templates');
     return this.templates;
-  }
+  });
 
   async loadTemplates() {
     this.templates = await this.store.query('template', {
@@ -31,8 +37,8 @@ export default class RdfaEditorStandardTemplatePluginService extends Service {
      @return {Array} Array of templates (filtered)
      @private
   */
-  templatesForContext(templates, rdfaTypes) {
-    let isMatchingForContext = (template) => {
+  templatesForContext(templates: TemplateModel[], rdfaTypes: string[]) {
+    const isMatchingForContext = (template: TemplateModel) => {
       return (
         rdfaTypes.filter((e) => template.get('contexts').includes(e)).length >
           0 &&

package/addon/utils/memoize.ts

@@ -0,0 +1,8 @@
+export default function memoize(func: (...a: unknown[]) => unknown) {
+  const cache: Record<string, unknown> = {};
+  return (...args: unknown[]) => {
+    const serializedArgs = JSON.stringify(args);
+    cache[serializedArgs] = cache[serializedArgs] || func(args);
+    return cache[serializedArgs];
+  };
+}

package/addon/utils/option.ts

@@ -0,0 +1,58 @@
+export abstract class CustomError extends Error {
+  constructor(message?: string) {
+    super(message);
+    this.name = this.constructor.name;
+  }
+}
+
+export class AssertionError extends CustomError {}
+
+export type None = null | undefined;
+export type Option<A> = A | None;
+
+export function expect<A>(msg: string, thing: Option<A>): A {
+  if (!isSome(thing)) {
+    throw new AssertionError(msg);
+  }
+  return thing;
+}
+
+export function unwrap<A>(thing: Option<A>): A {
+  return expect('Unwrapped a null or undefined value!', thing);
+}
+
+export function unwrapOr<A>(defaultValue: A, thing: Option<A>): A {
+  if (isSome(thing)) {
+    return thing;
+  }
+  return defaultValue;
+}
+
+export function optionMap<A, U>(
+  func: (thing: A) => U,
+  thing: Option<A>
+): Option<U> {
+  if (isSome(thing)) {
+    return func(thing);
+  }
+  return thing;
+}
+
+export function optionMapOr<A, U>(
+  defaultValue: U,
+  func: (thing: A) => U,
+  thing: Option<A>
+): U {
+  if (isSome(thing)) {
+    return func(thing);
+  }
+  return defaultValue;
+}
+
+export function isSome<A>(thing: Option<A>): thing is A {
+  return thing !== null && thing !== undefined;
+}
+
+export function isNone<A>(thing: Option<A>): thing is None {
+  return !isSome(thing);
+}

package/addon/utils/sparql-helpers.ts

@@ -0,0 +1,27 @@
+import * as RDF from '@rdfjs/types';
+
+export type QueryResult = {
+  results: {
+    bindings: Record<string, RDF.Term>[];
+  };
+};
+
+export async function executeQuery(endpoint: string, query: string) {
+  const encodedQuery = encodeURIComponent(query.trim());
+  const response = await fetch(endpoint, {
+    method: 'POST',
+    mode: 'cors',
+    headers: {
+      Accept: 'application/sparql-results+json',
+      'Content-Type': 'application/x-www-form-urlencoded; charset=UTF-8',
+    },
+    body: `query=${encodedQuery}`,
+  });
+  if (response.ok) {
+    return response.json() as unknown as QueryResult;
+  } else {
+    throw new Error(
+      `Request to MOW backend was unsuccessful: [${response.status}] ${response.statusText}`
+    );
+  }
+}

package/app/components/article-structure-plugin/article-structure-card.js

@@ -0,0 +1 @@
+export { default } from '@lblod/ember-rdfa-editor-lblod-plugins/components/article-structure-plugin/article-structure-card';

package/app/components/article-structure-plugin/structure-card.js

@@ -0,0 +1 @@
+export { default } from '@lblod/ember-rdfa-editor-lblod-plugins/components/article-structure-plugin/structure-card';

package/app/components/{citaten-plugin/citaat-card.js → au-native-input.js}

@@ -1 +1 @@
-export { default } from '@lblod/ember-rdfa-editor-lblod-plugins/components/citaten-plugin/citaat-card';
+export { default } from '@lblod/ember-rdfa-editor-lblod-plugins/components/au-native-input';

package/app/components/{citaten-plugin/citations/article-list.js → besluit-plugin/besluit-context-card.js}

@@ -1 +1 @@
-export { default } from '@lblod/ember-rdfa-editor-lblod-plugins/components/citaten-plugin/citations/article-list';
+export { default } from '@lblod/ember-rdfa-editor-lblod-plugins/components/besluit-plugin/besluit-context-card';

package/app/components/besluit-plugin/besluit-plugin-card.js

@@ -0,0 +1 @@
+export { default } from '@lblod/ember-rdfa-editor-lblod-plugins/components/besluit-plugin/besluit-plugin-card';

package/app/components/{citaten-plugin/citations/modal.js → citation-plugin/citation-card.js}

@@ -1 +1 @@
-export { default } from '@lblod/ember-rdfa-editor-lblod-plugins/components/citaten-plugin/citations/modal';
+export { default } from '@lblod/ember-rdfa-editor-lblod-plugins/components/citation-plugin/citation-card';

package/app/components/citation-plugin/citation-insert.js

@@ -0,0 +1 @@
+export { default } from '@lblod/ember-rdfa-editor-lblod-plugins/components/citation-plugin/citation-insert';

package/app/components/{citaten-plugin/citations/decision-list.js → citation-plugin/citations/article-list.js}

@@ -1 +1 @@
-export { default } from '@lblod/ember-rdfa-editor-lblod-plugins/components/citaten-plugin/citations/decision-list';
+export { default } from '@lblod/ember-rdfa-editor-lblod-plugins/components/citation-plugin/citations/article-list';

package/app/components/{citaten-plugin → citation-plugin}/citations/article-preview.js

@@ -1 +1 @@
-export { default } from '@lblod/ember-rdfa-editor-lblod-plugins/components/citaten-plugin/citations/article-preview';
+export { default } from '@lblod/ember-rdfa-editor-lblod-plugins/components/citation-plugin/citations/article-preview';

package/app/components/{citaten-plugin → citation-plugin}/citations/decision-detail.js

@@ -1 +1 @@
-export { default } from '@lblod/ember-rdfa-editor-lblod-plugins/components/citaten-plugin/citations/decision-detail';
+export { default } from '@lblod/ember-rdfa-editor-lblod-plugins/components/citation-plugin/citations/decision-detail';

package/app/components/citation-plugin/citations/decision-list.js

@@ -0,0 +1 @@
+export { default } from '@lblod/ember-rdfa-editor-lblod-plugins/components/citation-plugin/citations/decision-list';

package/app/components/{citaten-plugin → citation-plugin}/citations/decision-preview.js

@@ -1 +1 @@
-export { default } from '@lblod/ember-rdfa-editor-lblod-plugins/components/citaten-plugin/citations/decision-preview';
+export { default } from '@lblod/ember-rdfa-editor-lblod-plugins/components/citation-plugin/citations/decision-preview';

package/app/components/citation-plugin/citations/modal.js

@@ -0,0 +1 @@
+export { default } from '@lblod/ember-rdfa-editor-lblod-plugins/components/citation-plugin/citations/modal';

package/app/components/{citaten-plugin → citation-plugin}/citations/search-modal.js

@@ -1 +1 @@
-export { default } from '@lblod/ember-rdfa-editor-lblod-plugins/components/citaten-plugin/citations/search-modal';
+export { default } from '@lblod/ember-rdfa-editor-lblod-plugins/components/citation-plugin/citations/search-modal';

package/app/components/{citaten-plugin → citation-plugin}/helpers/alert-load-error.js

@@ -1 +1 @@
-export { default } from '@lblod/ember-rdfa-editor-lblod-plugins/components/citaten-plugin/helpers/alert-load-error';
+export { default } from '@lblod/ember-rdfa-editor-lblod-plugins/components/citation-plugin/helpers/alert-load-error';

package/app/components/{citaten-plugin → citation-plugin}/helpers/alert-no-items.js

@@ -1 +1 @@
-export { default } from '@lblod/ember-rdfa-editor-lblod-plugins/components/citaten-plugin/helpers/alert-no-items';
+export { default } from '@lblod/ember-rdfa-editor-lblod-plugins/components/citation-plugin/helpers/alert-no-items';

package/app/components/{citaten-plugin/citaat-insert.js → rdfa-date-plugin/card.js}

@@ -1 +1 @@
-export { default } from '@lblod/ember-rdfa-editor-lblod-plugins/components/citaten-plugin/citaat-insert';
+export { default } from '@lblod/ember-rdfa-editor-lblod-plugins/components/rdfa-date-plugin/card';

package/app/components/rdfa-date-plugin/date-time-picker.js

@@ -0,0 +1 @@
+export { default } from '@lblod/ember-rdfa-editor-lblod-plugins/components/rdfa-date-plugin/date-time-picker';

package/app/components/rdfa-date-plugin/insert.js

@@ -0,0 +1 @@
+export { default } from '@lblod/ember-rdfa-editor-lblod-plugins/components/rdfa-date-plugin/insert';

package/app/components/standard-template-plugin/card.js

@@ -0,0 +1 @@
+export { default } from '@lblod/ember-rdfa-editor-lblod-plugins/components/standard-template-plugin/card';

package/app/components/table-of-contents-plugin/ember-nodes/outline.js

@@ -0,0 +1 @@
+export { default } from '@lblod/ember-rdfa-editor-lblod-plugins/components/table-of-contents-plugin/ember-nodes/outline';

package/app/components/table-of-contents-plugin/ember-nodes/table-of-contents.js

@@ -0,0 +1 @@
+export { default } from '@lblod/ember-rdfa-editor-lblod-plugins/components/table-of-contents-plugin/ember-nodes/table-of-contents';

package/app/styles/citaten-plugin.scss

@@ -1,4 +1,4 @@
-@import '@appuniversum/ember-appuniversum/app/styles/ember-appuniversum';
+@import "ember-appuniversum";
 
 .citaten--decision-list {
   max-height: 35vh;

package/components/article-structure-plugin/article-structure-card.d.ts

@@ -0,0 +1,17 @@
+import Component from '@glimmer/component';
+import { ProseController } from '@lblod/ember-rdfa-editor';
+import IntlService from 'ember-intl/services/intl';
+import { ArticleStructurePluginOptions, StructureSpec } from '@lblod/ember-rdfa-editor-lblod-plugins/plugins/article-structure-plugin';
+type Args = {
+    controller: ProseController;
+    widgetArgs: {
+        options: ArticleStructurePluginOptions;
+    };
+};
+export default class EditorPluginsArticleStructureCardComponent extends Component<Args> {
+    intl: IntlService;
+    get structureTypes(): ArticleStructurePluginOptions;
+    insertStructure(spec: StructureSpec): void;
+    canInsertStructure: (spec: StructureSpec) => boolean;
+}
+export {};

package/components/article-structure-plugin/structure-card.d.ts

@@ -0,0 +1,32 @@
+import Component from '@glimmer/component';
+import { ProseController } from '@lblod/ember-rdfa-editor';
+import { ArticleStructurePluginOptions } from '@lblod/ember-rdfa-editor-lblod-plugins/plugins/article-structure-plugin';
+import IntlService from 'ember-intl/services/intl';
+type Args = {
+    controller: ProseController;
+    widgetArgs: {
+        options: ArticleStructurePluginOptions;
+    };
+};
+export default class EditorPluginsStructureCardComponent extends Component<Args> {
+    intl: IntlService;
+    removeStructureContent: boolean;
+    get controller(): ProseController;
+    moveStructure(direction: 'up' | 'down'): void;
+    removeStructure(): void;
+    setRemoveStructureContent(value: boolean): void;
+    get structureTypes(): ArticleStructurePluginOptions;
+    get structureNodeSpecs(): import("prosemirror-model").NodeType[];
+    get structure(): {
+        pos: number;
+        start: number;
+        depth: number;
+        node: import("prosemirror-model").Node;
+    } | undefined;
+    get currentStructureType(): import("@lblod/ember-rdfa-editor-lblod-plugins/plugins/article-structure-plugin").StructureSpec | undefined;
+    get isOutsideStructure(): boolean;
+    get canMoveDown(): boolean;
+    get canMoveUp(): boolean;
+    get canRemoveStructure(): boolean;
+}
+export {};

package/components/au-native-input.d.ts

@@ -0,0 +1,20 @@
+import Component from '@glimmer/component';
+interface Args {
+    width?: 'block';
+    iconAlignment?: 'left' | 'right';
+    error?: boolean;
+    warning?: boolean;
+    disabled?: boolean;
+    type?: string;
+    icon?: string;
+}
+export default class AuNativeInput extends Component<Args> {
+    constructor(owner: unknown, args: Args);
+    get width(): "au-c-input--block" | "";
+    get iconAlignment(): "" | "au-c-input-wrapper--left" | "au-c-input-wrapper--right";
+    get error(): "" | "au-c-input--error";
+    get warning(): "" | "au-c-input--warning";
+    get disabled(): "" | "is-disabled";
+    get type(): string;
+}
+export {};

package/components/besluit-plugin/besluit-context-card.d.ts

@@ -0,0 +1,24 @@
+import Component from '@glimmer/component';
+import { ResolvedPNode } from '@lblod/ember-rdfa-editor/plugins/datastore';
+import { ProseController } from '@lblod/ember-rdfa-editor';
+interface Args {
+    controller: ProseController;
+}
+export default class BesluitContextCardComponent extends Component<Args> {
+    articleElement?: ResolvedPNode;
+    constructor(parent: unknown, args: Args);
+    get controller(): ProseController;
+    get doc(): import("prosemirror-model").Node;
+    focus(): void;
+    deleteArticle(): void;
+    moveUpArticle(): void;
+    moveDownArticle(): void;
+    get disableMoveUp(): boolean;
+    get disableMoveDown(): boolean;
+    get besluitURI(): string | undefined;
+    get activeArticle(): {
+        uri: string;
+        range: ResolvedPNode;
+    } | undefined;
+}
+export {};

package/components/besluit-plugin/besluit-plugin-card.d.ts

@@ -0,0 +1,14 @@
+import Component from '@glimmer/component';
+import { ProseController } from '@lblod/ember-rdfa-editor';
+type Args = {
+    controller: ProseController;
+};
+export default class BesluitPluginCardComponent extends Component<Args> {
+    get controller(): ProseController;
+    focus(): void;
+    insertArticle(): void;
+    insertTitle(): void;
+    get hasTitle(): boolean;
+    get disableArticleInsert(): boolean;
+}
+export {};

package/components/besluit-type-plugin/besluit-type-select.d.ts

@@ -0,0 +1,11 @@
+import Component from '@glimmer/component';
+import { BesluitType } from '@lblod/ember-rdfa-editor-lblod-plugins/plugins/besluit-type-plugin/utils/fetchBesluitTypes';
+type Args = {
+    besluitTypes: BesluitType[];
+};
+export default class BesluitTypePluginBesluitTypeSelectComponent extends Component<Args> {
+    besluitTypes: BesluitType[];
+    constructor(parent: unknown, args: Args);
+    search(term: string): BesluitType[];
+}
+export {};