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

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

@@ -0,0 +1,46 @@
+import Component from '@glimmer/component';
+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';
+import { BesluitType } from '@lblod/ember-rdfa-editor-lblod-plugins/plugins/besluit-type-plugin/utils/fetchBesluitTypes';
+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 { ProseController } from '@lblod/ember-rdfa-editor/core/prosemirror';
+import { VariableType } from '@lblod/ember-rdfa-editor-lblod-plugins/plugins/insert-variable-plugin/utils/constants';
+import { CodeList } from '@lblod/ember-rdfa-editor-lblod-plugins/plugins/insert-variable-plugin/utils/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 {};

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

@@ -0,0 +1,17 @@
+import Component from '@glimmer/component';
+import StandardTemplatePluginService from '@lblod/ember-rdfa-editor-lblod-plugins/services/standard-template-plugin';
+import { ProseController } from '@lblod/ember-rdfa-editor/core/prosemirror';
+import TemplateModel from '@lblod/ember-rdfa-editor-lblod-plugins/models/template';
+type Args = {
+    controller: ProseController;
+};
+export default class TemplateProviderComponent extends Component<Args> {
+    standardTemplatePlugin: StandardTemplatePluginService;
+    get busy(): boolean;
+    get controller(): ProseController;
+    get hasApplicableTemplates(): boolean;
+    get applicableTemplates(): TemplateModel[];
+    templateIsApplicable(template: TemplateModel): boolean;
+    insert(template: TemplateModel): Promise<void>;
+}
+export {};

package/components/table-of-contents-plugin/card.d.ts

@@ -0,0 +1,20 @@
+import Component from '@glimmer/component';
+import { TableOfContentsConfig } from '@lblod/ember-rdfa-editor-lblod-plugins/plugins/table-of-contents-plugin/utils/constants';
+import { ProseController } from '@lblod/ember-rdfa-editor/core/prosemirror';
+type Args = {
+    controller: ProseController;
+    widgetArgs: {
+        config: TableOfContentsConfig;
+    };
+};
+export default class TableOfContentsCardComponent extends Component<Args> {
+    get toggled(): boolean;
+    get controller(): ProseController;
+    get tableOfContentsRange(): {
+        from: number;
+        to: number;
+    } | undefined;
+    get config(): TableOfContentsConfig;
+    toggle(): void;
+}
+export {};

package/components/table-of-contents-plugin/ember-nodes/table-of-contents.d.ts

@@ -0,0 +1,22 @@
+import Component from '@glimmer/component';
+import { PNode } from '@lblod/ember-rdfa-editor';
+import { EmberNodeArgs } from '@lblod/ember-rdfa-editor/utils/ember-node';
+import { TableOfContentsConfig } from '@lblod/ember-rdfa-editor-lblod-plugins/plugins/table-of-contents-plugin/utils/constants';
+type OutlineEntry = {
+    content: string;
+    pos: number;
+    children?: OutlineEntry[];
+};
+export default class TableOfContentsComponent extends Component<EmberNodeArgs> {
+    get config(): TableOfContentsConfig;
+    get controller(): import("@lblod/ember-rdfa-editor").ProseController;
+    get outline(): {
+        entries: OutlineEntry[];
+    };
+    extractOutline({ node, pos }: {
+        node: PNode;
+        pos: number;
+    }): OutlineEntry[];
+    moveToPosition(pos: number): void;
+}
+export {};

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

@@ -0,0 +1,27 @@
+import Component from '@glimmer/component';
+import { ProseController } from '@lblod/ember-rdfa-editor/core/prosemirror';
+import { ProseStore } from '@lblod/ember-rdfa-editor/utils/datastore/prose-store';
+import { CodeListOption } from '@lblod/ember-rdfa-editor-lblod-plugins/plugins/template-variable-plugin/utils/fetch-data';
+type Args = {
+    controller: ProseController;
+};
+export default class EditorPluginsTemplateVariableCardComponent extends Component<Args> {
+    variableOptions: CodeListOption[];
+    selectedVariable?: CodeListOption | CodeListOption[];
+    showCard: boolean;
+    multiSelect: boolean;
+    mappingUri?: string;
+    zonalLocationCodelistUri: string;
+    endpoint: string;
+    nonZonalLocationCodelistUri: string;
+    constructor(parent: unknown, args: Args);
+    get controller(): ProseController;
+    insert(): void;
+    wrapVariableInHighlight(text: string): string;
+    selectionChanged(): void;
+    getCodelistSource(fullDatastore: ProseStore, mappingUri: string): string;
+    updateVariable(variable: CodeListOption | CodeListOption[]): void;
+    fetchCodeListOptions: import("ember-concurrency").TaskForAsyncTaskFunction<unknown, (endpoint: string, codelistUri: string, isLocation?: boolean) => Promise<void>>;
+    wrapInLocation(value: string): string;
+}
+export {};

package/helpers/limit-text.d.ts

@@ -0,0 +1,8 @@
+declare const _default: import("@ember/component/helper").FunctionBasedHelper<{
+    Args: {
+        Positional: string[];
+        Named: import("@ember/component/helper").EmptyObject;
+    };
+    Return: string;
+}>;
+export default _default;

package/index.js

@@ -5,4 +5,9 @@ module.exports = {
   isDevelopingAddon() {
     return process.env.EMBER_ENV === 'development';
   },
+  options: {
+    babel: {
+      sourceMaps: 'inline',
+    },
+  },
 };

package/models/instruction.d.ts

@@ -0,0 +1,8 @@
+import { IBindings } from 'fetch-sparql-endpoint';
+export default class Instruction {
+    readonly name: string;
+    readonly template: string;
+    readonly annotatedTemplate: string;
+    constructor(name: string, template: string, annotatedTemplate: string);
+    static fromBinding(binding: IBindings): Instruction;
+}

package/models/measure.d.ts

@@ -0,0 +1,14 @@
+import { IBindings } from 'fetch-sparql-endpoint';
+import Sign from './sign';
+export default class Measure {
+    readonly uri: string;
+    readonly label: string;
+    readonly template: string;
+    readonly annotatedTemplate: string;
+    readonly zonality: string;
+    readonly temporal: string | false;
+    signs: Sign[];
+    classifications: Set<unknown>;
+    constructor(uri: string, label: string, template: string, annotatedTemplate: string, zonality: string, temporal: string | false, signs?: Sign[]);
+    static fromBinding(binding: IBindings): Measure;
+}

package/models/sign.d.ts

@@ -0,0 +1,12 @@
+import { IBindings } from 'fetch-sparql-endpoint';
+export default class Sign {
+    readonly code: string;
+    readonly image: string;
+    readonly classifications: string[];
+    readonly uri: string;
+    readonly order: string;
+    readonly zonality: string;
+    constructor(code: string, image: string, classifications: string[], uri: string, order: string, zonality: string);
+    static fromBinding(binding: IBindings): Sign;
+    static processImage(url: string, imageBaseUrl: string): string;
+}

package/models/template.d.ts

@@ -0,0 +1,13 @@
+import Model from '@ember-data/model';
+declare module 'ember-data/types/registries/model' {
+    export default interface ModelRegistry {
+        template: TemplateModel;
+    }
+}
+export default class TemplateModel extends Model {
+    title: string;
+    matches: string[];
+    body: string;
+    contexts: string[];
+    disabledInContexts: string[];
+}