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

package/commands/besluit-plugin/index.d.ts

@@ -0,0 +1,4 @@
+export { default as insertArticle } from './insert-article';
+export { default as insertTitle } from './insert-title';
+export { default as moveArticle } from './move-article';
+export { default as recalculateArticleNumbers } from './recalculate-article-numbers';

package/commands/besluit-plugin/insert-article.d.ts

@@ -0,0 +1,3 @@
+import { ProseController } from '@lblod/ember-rdfa-editor';
+import { Command } from '@lblod/ember-rdfa-editor';
+export default function insertArticle(controller: ProseController, articleContent: string, articleNumber: string): Command;

package/commands/besluit-plugin/insert-title.d.ts

@@ -0,0 +1,2 @@
+import { Command, ProseController } from '@lblod/ember-rdfa-editor';
+export default function insertTitle(controller: ProseController, title: string): Command;

package/commands/besluit-plugin/move-article.d.ts

@@ -0,0 +1,2 @@
+import { Command, ProseController } from '@lblod/ember-rdfa-editor';
+export default function moveArticleCommand(controller: ProseController, besluitUri: string, articleUri: string, moveUp: boolean): Command;

package/commands/besluit-plugin/recalculate-article-numbers.d.ts

@@ -0,0 +1,2 @@
+import { ProseController } from '@lblod/ember-rdfa-editor';
+export default function recalculateArticleNumbers(controller: ProseController, besluitUri: string): void;

package/commands/modify-date-command.d.ts

@@ -0,0 +1,2 @@
+import { Command } from '@lblod/ember-rdfa-editor';
+export default function modifyDate(from: number, to: number, dateValue: Date, onlyDate: boolean): Command;

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

@@ -0,0 +1,36 @@
+import Component from '@glimmer/component';
+import { ProseController } from '@lblod/ember-rdfa-editor';
+import IntlService from 'ember-intl/services/intl';
+import { ResolvedArticleStructurePluginOptions } from '@lblod/ember-rdfa-editor-lblod-plugins/plugins/article-structure-plugin';
+type Args = {
+    controller: ProseController;
+    widgetArgs: {
+        options: ResolvedArticleStructurePluginOptions;
+    };
+};
+export default class EditorPluginsArticleStructureCardComponent extends Component<Args> {
+    intl: IntlService;
+    structures: import("ember-resources/util/function").State<{
+        canExecute: boolean;
+        uriBase: string;
+        title: string;
+        type: string;
+        numberPredicate: string;
+        numbering?: string | undefined;
+        numberingFunction?: ((num: number) => string) | undefined;
+        heading?: string | undefined;
+        translation: string;
+        moveUp: string;
+        moveDown: string;
+        insertPredicate?: {
+            long: string;
+            short: string;
+        } | undefined;
+        shaclConstraint: string;
+        template: (uri: string, intlService: IntlService) => string;
+    }[]>;
+    insertStructure(structureName: string): Promise<void>;
+    get structureUri(): string | undefined;
+    get isOutsideStructure(): boolean;
+}
+export {};

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

@@ -0,0 +1,23 @@
+import Component from '@glimmer/component';
+import { ProseController } from '@lblod/ember-rdfa-editor';
+import { ResolvedArticleStructurePluginOptions } from '@lblod/ember-rdfa-editor-lblod-plugins/plugins/article-structure-plugin';
+type Args = {
+    controller: ProseController;
+    widgetArgs: {
+        options: ResolvedArticleStructurePluginOptions;
+    };
+};
+export default class EditorPluginsStructureCardComponent extends Component<Args> {
+    get controller(): ProseController;
+    moveStructure(moveUp: boolean): Promise<void>;
+    removeStructure(): void;
+    get structure(): {
+        uri: string;
+        type: string;
+    } | undefined;
+    get structureTypeSelected(): import("@lblod/ember-rdfa-editor-lblod-plugins/plugins/article-structure-plugin").StructureSpec | undefined;
+    get isOutsideStructure(): boolean;
+    canMoveDown: import("ember-resources/util/function").State<boolean>;
+    canMoveUp: import("ember-resources/util/function").State<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,29 @@
+import Component from '@glimmer/component';
+import { ResolvedPNode } from '@lblod/ember-rdfa-editor/plugins/datastore';
+import { DecisionOptions } from '@lblod/ember-rdfa-editor-lblod-plugins/plugins/besluit-plugin';
+import { ProseController } from '@lblod/ember-rdfa-editor';
+interface ContextCardWidgetArgs {
+    options?: DecisionOptions;
+}
+interface Args {
+    controller: ProseController;
+    widgetArgs: ContextCardWidgetArgs;
+}
+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/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 {};

package/components/besluit-type-plugin/toolbar-dropdown.d.ts

@@ -0,0 +1,46 @@
+import Component from '@glimmer/component';
+import { BesluitType } from '../../utils/fetchBesluitTypes';
+import { ProseController } from '@lblod/ember-rdfa-editor/core/prosemirror';
+import CurrentSessionService from '@lblod/frontend-gelinkt-notuleren/services/current-session';
+import { ResolvedPNode } from '@lblod/ember-rdfa-editor/plugins/datastore';
+declare module 'ember__owner' {
+    export default interface Owner {
+        resolveRegistration(name: string): unknown;
+    }
+}
+type Args = {
+    controller: ProseController;
+};
+export default class EditorPluginsToolbarDropdownComponent extends Component<Args> {
+    currentSession: CurrentSessionService;
+    /**
+     * Actual besluit type selected
+     * @property besluitType
+     * @type BesluitType
+     * @private
+     */
+    besluitType?: BesluitType;
+    previousBesluitType?: string;
+    types: BesluitType[];
+    besluit?: BesluitType;
+    subBesluit?: BesluitType;
+    subSubBesluit?: BesluitType;
+    cardExpanded: boolean;
+    loadDataTaskInstance: import("ember-concurrency").TaskInstance<void>;
+    constructor(parent: unknown, args: Args);
+    get controller(): ProseController;
+    get doc(): import("prosemirror-model").Node;
+    loadData: import("ember-concurrency").TaskForAsyncTaskFunction<unknown, () => Promise<void>>;
+    get currentBesluitRange(): ResolvedPNode | undefined;
+    get currentBesluitURI(): string | undefined;
+    get showCard(): boolean;
+    updateBesluitTypes(): void;
+    updateBesluitType(selected: BesluitType): void;
+    updateBesluitSubType(selected: BesluitType): void;
+    updateBesluitSubSubType(selected: BesluitType): void;
+    findBesluitTypeParent(besluitType?: BesluitType, array?: BesluitType[], parent?: BesluitType): BesluitType | undefined;
+    findBesluitTypeByURI(uri: string, types?: BesluitType[]): BesluitType | undefined;
+    insert(): void;
+    toggleCard(): void;
+}
+export {};

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

@@ -0,0 +1,51 @@
+import Component from '@glimmer/component';
+import { Article, Decision } from '../../plugins/citation-plugin/utils/vlaamse-codex';
+import { Option } from '@lblod/ember-rdfa-editor-lblod-plugins/utils/option';
+import { CitationDecoration, CitationPlugin } from '@lblod/ember-rdfa-editor-lblod-plugins/plugins/citation-plugin';
+import { ProseController } from '@lblod/ember-rdfa-editor';
+interface Args {
+    controller: ProseController;
+    widgetArgs: {
+        plugin: CitationPlugin;
+    };
+}
+export default class CitationCardComponent extends Component<Args> {
+    pageNumber: number;
+    pageSize: number;
+    totalSize: number;
+    totalCount: number;
+    decisions: never[];
+    error: unknown;
+    showModal: boolean;
+    decision: Decision | null;
+    cardText: string | null;
+    cardLegislationType: string | null;
+    get controller(): ProseController;
+    get showCard(): Option<CitationDecoration>;
+    get plugin(): CitationPlugin;
+    get decorations(): import("prosemirror-view").DecorationSet | undefined;
+    get activeDecoration(): Option<CitationDecoration>;
+    get documentLegislationType(): Option<string>;
+    get documentText(): Option<string>;
+    get searchText(): string;
+    get legislationTypes(): string[];
+    get selectedLegislationType(): {
+        label: string;
+        value: string;
+    };
+    get selectedLegislationTypeLabel(): string;
+    get selectedLegislationTypeUri(): string;
+    resetToDocumentState(): void;
+    onCardTextChange(event: InputEvent): void;
+    resourceSearch: import("ember-concurrency").TaskForAsyncTaskFunction<unknown, () => Promise<Decision[]>>;
+    decisionResource: import("ember-resources/util/ember-concurrency").TaskInstance<unknown>;
+    selectLegislationType(type: string): void;
+    openDecisionDetailModal(decision: Decision): void;
+    openSearchModal(): Promise<void>;
+    closeModal(lastSearchType: string, lastSearchTerm: string): void;
+    insertDecisionCitation(decision: Decision): void;
+    insertArticleCitation(decision: Decision, article: Article): void;
+    focus(): void;
+    willDestroy(): void;
+}
+export {};

package/components/citation-plugin/citation-insert.d.ts

@@ -0,0 +1,24 @@
+import Component from '@glimmer/component';
+import { ProseController } from '@lblod/ember-rdfa-editor';
+import { Article, Decision } from '@lblod/ember-rdfa-editor-lblod-plugins/plugins/citation-plugin/utils/vlaamse-codex';
+import { CitationPlugin } from '@lblod/ember-rdfa-editor-lblod-plugins/plugins/citation-plugin';
+interface Args {
+    controller: ProseController;
+    widgetArgs: {
+        plugin: CitationPlugin;
+    };
+}
+export default class EditorPluginsCitationInsertComponent extends Component<Args> {
+    showModal: boolean;
+    legislationTypeUri: string;
+    text: string;
+    get disableInsert(): boolean;
+    get plugin(): CitationPlugin;
+    get activeRanges(): [number, number][] | undefined;
+    get controller(): ProseController;
+    openModal(): void;
+    closeModal(): void;
+    insertDecisionCitation(decision: Decision): void;
+    insertArticleCitation(decision: Decision, article: Article): void;
+}
+export {};

package/components/citation-plugin/citations/decision-detail.d.ts

@@ -0,0 +1,26 @@
+import Component from '@glimmer/component';
+import { Decision } from '../../../plugins/citation-plugin/utils/vlaamse-codex';
+interface Args {
+    decision: Decision;
+    close: () => void;
+}
+export default class EditorPluginsCitationsDecisionDetailComponent extends Component<Args> {
+    error: unknown;
+    pageNumber: number;
+    pageSize: number;
+    totalCount: number;
+    articles: never[];
+    articleFilter: string;
+    articleFilterAfterTimeout: string;
+    updateArticleFilter: import("ember-concurrency").TaskForAsyncTaskFunction<unknown, () => Promise<void>>;
+    resourceSearch: import("ember-concurrency").TaskForAsyncTaskFunction<unknown, () => Promise<import("../../../plugins/citation-plugin/utils/vlaamse-codex").Article[]>>;
+    articleResource: import("ember-resources/util/ember-concurrency").TaskInstance<unknown>;
+    close(): Promise<void>;
+    previousPage(): void;
+    nextPage(): void;
+    get rangeStart(): number;
+    get rangeEnd(): number;
+    get isFirstPage(): boolean;
+    get isLastPage(): boolean;
+}
+export {};

package/components/citation-plugin/citations/search-modal.d.ts

@@ -0,0 +1,67 @@
+import Component from '@glimmer/component';
+import { Article, Decision } from '../../../plugins/citation-plugin/utils/vlaamse-codex';
+import IntlService from 'ember-intl/services/intl';
+interface Args {
+    selectedDecision: Decision;
+    legislationTypeUri: string;
+    text: string;
+    insertDecisionCitation: (decision: Decision) => void;
+    insertArticleCitation: (decision: Decision, article: Article) => void;
+    closeModal: (legislationTypeUri?: string, text?: string) => void;
+}
+export default class EditorPluginsCitationsSearchModalComponent extends Component<Args> {
+    intl: IntlService;
+    legislationTypeUri: string;
+    pageNumber: number;
+    pageSize: number;
+    totalCount: number;
+    decisions: never[];
+    error: unknown;
+    selectedDecision: Decision | null;
+    documentDateFrom: Date | null;
+    documentDateTo: Date | null;
+    publicationDateFrom: Date | null;
+    publicationDateTo: Date | null;
+    inputSearchText: string | null;
+    minDate: Date;
+    maxDate: Date;
+    constructor(owner: unknown, args: Args);
+    get datePickerLocalization(): {
+        buttonLabel: string;
+        selectedDateMessage: string;
+        prevMonthLabel: string;
+        nextMonthLabel: string;
+        monthSelectLabel: string;
+        yearSelectLabel: string;
+        closeLabel: string;
+        keyboardInstruction: string;
+        calendarHeading: string;
+        dayNames: string[];
+        monthNames: string[];
+        monthNamesShort: string[];
+    };
+    get legislationTypes(): string[];
+    get legislationSelected(): string;
+    get text(): string;
+    get searchText(): string;
+    get rangeStart(): number;
+    get rangeEnd(): number;
+    get isFirstPage(): boolean;
+    get isLastPage(): boolean;
+    resourceSearch: import("ember-concurrency").TaskForAsyncTaskFunction<unknown, () => Promise<Decision[]>>;
+    decisionResource: import("ember-resources/util/ember-concurrency").TaskInstance<unknown>;
+    setInputSearchText(event: InputEvent): void;
+    selectLegislationType(type: string): void;
+    updateDocumentDateFrom(_isoDate: unknown, date: Date): void;
+    updateDocumentDateTo(_isoDate: unknown, date: Date): void;
+    updatePublicationDateFrom(_isoDate: unknown, date: Date): void;
+    updatePublicationDateTo(_isoDate: unknown, date: Date): void;
+    insertDecisionCitation(decision: Decision): Promise<void>;
+    insertArticleCitation(decision: Decision, article: Article): Promise<void>;
+    closeModal(legislationTypeUri?: string, text?: string): Promise<void>;
+    openDecisionDetail(decision: Decision): void;
+    closeDecisionDetail(): void;
+    previousPage(): void;
+    nextPage(): void;
+}
+export {};

package/components/import-snippet-plugin/card.d.ts

@@ -0,0 +1,19 @@
+import Component from '@glimmer/component';
+import { ProseController } from '@lblod/ember-rdfa-editor/core/prosemirror';
+import ImportRdfaSnippet from '@lblod/ember-rdfa-editor-lblod-plugins/services/import-rdfa-snippet';
+import { RdfaSnippet } from '@lblod/ember-rdfa-editor-lblod-plugins/services/import-rdfa-snippet';
+type Args = {
+    controller: ProseController;
+};
+export default class ImportSnippetPluginCard extends Component<Args> {
+    importRdfaSnippet: ImportRdfaSnippet;
+    get controller(): ProseController;
+    get snippets(): RdfaSnippet[];
+    get insertRange(): import("prosemirror-state").Selection | {
+        from: number;
+        to: number;
+    };
+    insert(snippet: RdfaSnippet, type: string): void;
+    generateSnippetHtml(snippet: RdfaSnippet, type: string): import("prosemirror-model").Node;
+}
+export {};

package/components/insert-variable-plugin/insert-variable-card.d.ts

@@ -0,0 +1,31 @@
+import Component from '@glimmer/component';
+import { VariableType } from '../../utils/variable-plugins/default-variable-types';
+import { ProseController } from '@lblod/ember-rdfa-editor/core/prosemirror';
+import { CodeList } from '@lblod/ember-rdfa-editor-lblod-plugins/utils/variable-plugins/fetch-data';
+type Args = {
+    controller: ProseController;
+    widgetArgs: {
+        options: {
+            publisher: string;
+            variableTypes: (VariableType | string)[];
+            defaultEndpoint: string;
+        };
+    };
+};
+export default class EditorPluginsInsertCodelistCardComponent extends Component<Args> {
+    variablesArray: VariableType[];
+    selectedVariable?: VariableType;
+    showCard: boolean;
+    hasSubtype: boolean;
+    selectedSubtype?: CodeList;
+    subtypes?: CodeList[];
+    publisher: string;
+    endpoint: string;
+    constructor(parent: unknown, args: Args);
+    insert(): void;
+    updateSelectedVariable(variable: VariableType): void;
+    fetchSubtypes: import("ember-concurrency").TaskForAsyncTaskFunction<unknown, (fetchFunction: (endpoint: string, publisher: string) => Promise<CodeList[]>) => Promise<void>>;
+    updateSubtype(subtype: CodeList): void;
+    selectionChanged(): void;
+}
+export {};

package/components/rdfa-date-plugin/card.d.ts

@@ -0,0 +1,20 @@
+import Component from '@glimmer/component';
+import { ProseController } from '@lblod/ember-rdfa-editor/core/prosemirror';
+type Args = {
+    controller: ProseController;
+};
+export default class RdfaDatePluginCardComponent extends Component<Args> {
+    dateValue?: Date;
+    dateRange?: {
+        from: number;
+        to: number;
+    };
+    dateInDocument: boolean;
+    onlyDate: boolean;
+    showCard: boolean;
+    get controller(): ProseController;
+    modifyDate(): void;
+    changeDate(date: Date): void;
+    onSelectionChanged(): void;
+}
+export {};

package/components/rdfa-date-plugin/date-time-picker.d.ts

@@ -0,0 +1,32 @@
+import Component from '@glimmer/component';
+import Intl from 'ember-intl/services/intl';
+type Args = {
+    value: Date;
+    onChange: (date: Date) => void;
+};
+export default class RdfaDatePluginDateTimePicker extends Component<Args> {
+    intl: Intl;
+    date: Date;
+    get hours(): number;
+    get minutes(): number;
+    get datePickerLocalization(): {
+        buttonLabel: string;
+        selectedDateMessage: string;
+        prevMonthLabel: string;
+        nextMonthLabel: string;
+        monthSelectLabel: string;
+        yearSelectLabel: string;
+        closeLabel: string;
+        keyboardInstruction: string;
+        calendarHeading: string;
+        dayNames: string[];
+        monthNames: string[];
+        monthNamesShort: string[];
+    };
+    onChangeDate(_isoDate: unknown, date: Date): void;
+    onChangeTime(timeObject: {
+        hours: number;
+        minutes: number;
+    }): void;
+}
+export {};

package/components/rdfa-date-plugin/insert.d.ts

@@ -0,0 +1,12 @@
+import Component from '@glimmer/component';
+import { ProseController } from '@lblod/ember-rdfa-editor/core/prosemirror';
+type Args = {
+    controller: ProseController;
+};
+export default class RdfaDatePluginInsertComponent extends Component<Args> {
+    get controller(): ProseController;
+    get schema(): import("prosemirror-model").Schema<any, any>;
+    insertDate(): void;
+    insertDateTime(): void;
+}
+export {};

package/components/roadsign-regulation-plugin/expanded-measure.d.ts

@@ -0,0 +1,20 @@
+import Component from '@glimmer/component';
+import Measure from '@lblod/ember-rdfa-editor-lblod-plugins/models/measure';
+type Args = {
+    measure: Measure;
+    selectRow: (uri: string) => void;
+    insert: (measure: Measure, zonalityValue?: string, temporalValue?: string) => void;
+};
+export default class ExpandedMeasureComponent extends Component<Args> {
+    zonalityValue?: string;
+    temporalValue?: string;
+    ZONAL_URI: string;
+    NON_ZONAL_URI: string;
+    get isPotentiallyZonal(): boolean;
+    get insertButtonDisabled(): boolean;
+    changeZonality(event: InputEvent): void;
+    changeTemporality(event: InputEvent): void;
+    insert(): void;
+    unselectRow(): void;
+}
+export {};

package/components/roadsign-regulation-plugin/measure-template.d.ts

@@ -0,0 +1,14 @@
+import Component from '@glimmer/component';
+import RoadsignRegistryService from '@lblod/ember-rdfa-editor-lblod-plugins/services/roadsign-registry';
+type Args = {
+    template: string;
+    measure: string;
+    annotated: boolean;
+};
+export default class MeasureTemplateComponent extends Component<Args> {
+    roadsignRegistry: RoadsignRegistryService;
+    template: string;
+    constructor(parent: unknown, args: Args);
+    fetchData: import("ember-concurrency").TaskForAsyncTaskFunction<unknown, () => Promise<void>>;
+}
+export {};

package/components/roadsign-regulation-plugin/roadsign-regulation-card.d.ts

@@ -0,0 +1,12 @@
+import Component from '@glimmer/component';
+import { ProseController } from '@lblod/ember-rdfa-editor/core/prosemirror';
+type Args = {
+    controller: ProseController;
+};
+export default class RoadsignRegulationCard extends Component<Args> {
+    modalOpen: boolean;
+    toggleModal(): void;
+    get controller(): ProseController;
+    get showCard(): boolean;
+}
+export {};

package/components/roadsign-regulation-plugin/roadsigns-modal.d.ts

@@ -0,0 +1,57 @@
+import Component from '@glimmer/component';
+import RoadsignRegistryService from '@lblod/ember-rdfa-editor-lblod-plugins/services/roadsign-registry';
+import Measure from '@lblod/ember-rdfa-editor-lblod-plugins/models/measure';
+import { ProseController } from '@lblod/ember-rdfa-editor/core/prosemirror';
+type Option = {
+    label: string;
+    value: string;
+};
+type Zonality = Option;
+type TypeOption = Option;
+type Code = Option;
+type Category = Option;
+type Args = {
+    closeModal: () => void;
+    controller: ProseController;
+};
+export default class RoadsignRegulationCard extends Component<Args> {
+    endpoint: string;
+    pageSize: number;
+    roadsignRegistry: RoadsignRegistryService;
+    typeSelected?: TypeOption;
+    categorySelected?: Category;
+    zonalityOptions: Zonality[];
+    zonalitySelected?: Zonality;
+    descriptionFilter?: string;
+    selectedCode?: Code;
+    selectedCodeCombination?: Code[];
+    codeCombinationOptions: Code[];
+    tableData: Measure[];
+    count?: number;
+    pageStart: number;
+    get isNotTypeSign(): boolean;
+    constructor(parent: unknown, args: Args);
+    selectTypeOrCategory(option: Option): void;
+    changeCode(value: Code): void;
+    changeCodeCombination(value: Code[]): void;
+    changeDescription(event: InputEvent): void;
+    selectCategory(value: Category): void;
+    selectZonality(value: Zonality): void;
+    closeModal(): void;
+    searchCodes(term: string): import("ember-concurrency").TaskInstance<{
+        value: string;
+        label: string;
+    }[]>;
+    fetchCodeCombinations(): Promise<void>;
+    get typeOptions(): {
+        groupName: string;
+        options: TypeOption[];
+    }[];
+    fetchSigns: import("ember-concurrency").TaskForAsyncTaskFunction<{
+        restartable: boolean;
+    }, () => Promise<void>>;
+    insertHtml(measure: Measure, zonalityValue: string, temporalValue: string): Promise<void>;
+    goToPage(pageStart: number): void;
+    search(): void;
+}
+export {};

package/components/roadsign-regulation-plugin/roadsigns-pagination.d.ts

@@ -0,0 +1,19 @@
+import Component from '@glimmer/component';
+type Args = {
+    count: number;
+    pageSize: number;
+    goToPage: (n: number) => void;
+};
+export default class RoadsignsPagination extends Component<Args> {
+    actualPageStart: number;
+    actualPageEnd: number;
+    get hasNextPage(): boolean;
+    get hasPreviousPage(): boolean;
+    get count(): number;
+    get pageStart(): number;
+    get pageEnd(): number;
+    onUpdateCount(_element: HTMLElement, [_, pageStart]: [number, number]): void;
+    goToPreviousPage(): void;
+    goToNextPage(): void;
+}
+export {};

package/components/roadsign-regulation-plugin/roadsigns-table.d.ts

@@ -0,0 +1,9 @@
+import Component from '@glimmer/component';
+type Args = Record<string, never>;
+export default class RoadsignsTable extends Component<Args> {
+    selected?: string;
+    imageBaseUrl: string;
+    constructor(parent: unknown, args: Args);
+    selectRow(id: string): void;
+}
+export {};

package/components/standard-template-plugin/card.d.ts

@@ -0,0 +1,9 @@
+import Component from '@glimmer/component';
+import { ProseController } from '@lblod/ember-rdfa-editor/core/prosemirror';
+type Args = {
+    controller: ProseController;
+};
+export default class StandardTemplatePluginCardComponent extends Component<Args> {
+    get controller(): ProseController;
+}
+export {};