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

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/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 { TableOfContentsConfig } from '../../../constants';
+import { PNode } from '@lblod/ember-rdfa-editor';
+import { EmberNodeArgs } from '@lblod/ember-rdfa-editor/utils/ember-node';
+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 { CodeListOption } from '../../utils/variable-plugins/fetch-data';
+import { ProseController } from '@lblod/ember-rdfa-editor/core/prosemirror';
+import { ProseStore } from '@lblod/ember-rdfa-editor/utils/datastore/prose-store';
+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/constants.d.ts

@@ -0,0 +1,11 @@
+export type TableOfContentsConfig = {
+    sectionPredicate: string[];
+    value: string | {
+        predicate: string;
+    };
+}[];
+export declare const TABLE_OF_CONTENTS_DEFAULT_CONFIG: TableOfContentsConfig;
+export declare const ZONAL_URI = "http://lblod.data.gift/concepts/c81c6b96-736a-48cf-b003-6f5cc3dbc55d";
+export declare const POTENTIALLY_ZONAL_URI = "http://lblod.data.gift/concepts/8f9367b2-c717-4be7-8833-4c75bbb4ae1f";
+export declare const NON_ZONAL_URI = "http://lblod.data.gift/concepts/b651931b-923c-477c-8da9-fc7dd841fdcc";
+export declare const MULTI_SELECT_CODELIST_TYPE = "http://lblod.data.gift/concepts/57C93E12-A02C-4D4B-8B95-666B6701286C";

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

@@ -0,0 +1,4 @@
+import { EmberNodeConfig } from '@lblod/ember-rdfa-editor/utils/ember-node';
+export declare const emberNodeConfig: EmberNodeConfig;
+export declare const tableOfContents: import("prosemirror-model").NodeSpec;
+export declare const tableOfContentsView: (controller: import("@lblod/ember-rdfa-editor/addon").ProseController) => import("prosemirror-view").NodeViewConstructor;

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[];
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lblod/ember-rdfa-editor-lblod-plugins",
-  "version": "0.4.1",
+  "version": "1.0.0-alpha.1",
   "description": "Ember addon providing lblod specific plugins for the ember-rdfa-editor",
   "keywords": [
     "ember-addon",
@@ -30,17 +30,29 @@
     "postpack": "ember ts:clean"
   },
   "dependencies": {
+    "@lblod/marawa": "^0.8.0-beta.2",
+    "@rdfjs/data-model": "^2.0.1",
+    "@rdfjs/dataset": "^2.0.1",
+    "@rdfjs/parser-n3": "^2.0.1",
+    "@types/rdf-validate-shacl": "^0.4.0",
+    "@types/rdfjs__parser-n3": "^1.1.5",
     "buffer": "^6.0.3",
     "ember-auto-import": "^2.4.1",
     "ember-cli-babel": "^7.26.11",
     "ember-cli-htmlbars": "^6.0.1",
     "ember-cli-typescript": "^5.2.1",
+    "ember-concurrency": "^2.3.7",
     "ember-mu-transform-helpers": "^2.0.0",
     "ember-power-select": "^5.0.4",
     "ember-resources": "^5.6.0",
     "fetch-sparql-endpoint": "^3.0.0",
     "process": "0.11.10",
-    "uuid": "^8.3.2"
+    "prosemirror-state": "^1.4.2",
+    "rdf-ext": "^2.1.0",
+    "rdf-validate-shacl": "^0.4.5",
+    "stream-browserify": "^3.0.0",
+    "tracked-built-ins": "^3.1.0",
+    "uuid": "^9.0.0"
   },
   "devDependencies": {
     "@appuniversum/ember-appuniversum": "^1.5.0",
@@ -49,8 +61,8 @@
     "@embroider/test-setup": "^1.6.0",
     "@glimmer/component": "^1.1.2",
     "@glimmer/tracking": "^1.1.2",
-    "@lblod/ember-rdfa-editor": "^0.64.0",
-    "@lblod/ember-rdfa-editor-besluit-plugin": "0.5.7",
+    "@lblod/ember-rdfa-editor": "^1.0.0-alpha.12",
+    "@rdfjs/types": "^1.1.0",
     "@release-it-plugins/lerna-changelog": "^5.0.0",
     "@tsconfig/ember": "^1.0.1",
     "@types/ember": "^4.0.2",
@@ -72,6 +84,7 @@
     "@types/ember__test": "^4.0.1",
     "@types/ember__test-helpers": "^2.8.2",
     "@types/ember__utils": "^4.0.2",
+    "@types/prosemirror-dev-tools": "^3.0.3",
     "@types/ember-data": "^4.4.6",
     "@types/ember-data__adapter": "^4.0.1",
     "@types/ember-data__model": "^4.0.0",
@@ -80,7 +93,13 @@
     "@types/ember-qunit": "^5.0.2",
     "@types/ember-resolver": "^5.0.13",
     "@types/qunit": "^2.19.3",
+    "@types/rdf-ext": "^1.3.11",
+    "@types/rdfjs__data-model": "^2.0.1",
+    "@types/rdfjs__dataset": "^2.0.0",
     "@types/rsvp": "^4.0.4",
+    "@types/uuid": "^9.0.0",
+    "@typescript-eslint/eslint-plugin": "^5.21.0",
+    "@typescript-eslint/parser": "^5.21.0",
     "babel-eslint": "^10.1.0",
     "broccoli-asset-rev": "^3.0.0",
     "ember-cli": "~4.4.1",
@@ -90,7 +109,6 @@
     "ember-cli-sri": "^2.1.1",
     "ember-cli-string-helpers": "^6.1.0",
     "ember-cli-terser": "^4.0.2",
-    "ember-concurrency": "^2.2.1",
     "ember-data": "^3.28.12",
     "ember-disable-prototype-extensions": "^1.1.3",
     "ember-export-application-global": "^2.0.1",
@@ -99,6 +117,7 @@
     "ember-page-title": "^7.0.0",
     "ember-qunit": "^5.1.5",
     "ember-resolver": "^8.0.3",
+    "ember-simple-auth": "4.2.2",
     "ember-source": "~4.4.0",
     "ember-source-channel-url": "^3.0.0",
     "ember-template-lint": "^4.8.0",
@@ -112,6 +131,7 @@
     "loader.js": "^4.7.0",
     "npm-run-all": "^4.1.5",
     "prettier": "^2.6.2",
+    "prosemirror-dev-tools": "^3.1.0",
     "qunit": "^2.19.1",
     "qunit-dom": "^2.0.0",
     "release-it": "^15.5.0",
@@ -122,9 +142,8 @@
   },
   "peerDependencies": {
     "@appuniversum/ember-appuniversum": "^1.5.0",
-    "@lblod/ember-rdfa-editor": ">=0.64.0",
-    "@rdfjs/data-model": "^2.0.1",
-    "ember-concurrency": "^2.0.0"
+    "@lblod/ember-rdfa-editor": "^1.0.0-alpha.12",
+    "ember-concurrency": "^2.3.7"
   },
   "engines": {
     "node": "12.* || 14.* || >= 16"

package/plugins/article-structure-plugin.d.ts

@@ -0,0 +1,29 @@
+import { WidgetSpec } from '@lblod/ember-rdfa-editor';
+import IntlService from 'ember-intl/services/intl';
+export type StructureSpec = {
+    uriBase: string;
+    title: string;
+    type: string;
+    numberPredicate: string;
+    numbering?: string;
+    numberingFunction?: (num: number) => string;
+    heading?: string;
+    translation: string;
+    moveUp: string;
+    moveDown: string;
+    insertPredicate?: {
+        long: string;
+        short: string;
+    };
+    shaclConstraint: string;
+    template: (uri: string, intlService: IntlService) => string;
+};
+export type ArticleStructurePluginOptions = {
+    structures: StructureSpec[];
+};
+export type ResolvedArticleStructurePluginOptions = {
+    structures: StructureSpec[];
+    structureTypes: string[];
+};
+export declare const articleStructureInsertWidget: (options?: ArticleStructurePluginOptions) => WidgetSpec;
+export declare const articleStructureContextWidget: (options?: ArticleStructurePluginOptions) => WidgetSpec;

package/plugins/besluit-plugin.d.ts

@@ -0,0 +1,9 @@
+import { WidgetSpec } from '@lblod/ember-rdfa-editor';
+import { VariableType } from '@lblod/ember-rdfa-editor-lblod-plugins/utils/variable-plugins/default-variable-types';
+export interface DecisionOptions {
+    publisher?: string;
+    variableTypes?: (VariableType | string)[];
+    defaultEndpoint?: string;
+}
+export declare function besluitPluginCardWidget(): WidgetSpec;
+export declare function besluitContextCardWidget(options?: DecisionOptions): WidgetSpec;

package/plugins/besluit-type-plugin.d.ts

@@ -0,0 +1,2 @@
+import { WidgetSpec } from '@lblod/ember-rdfa-editor/core/prosemirror';
+export declare const besluitTypeWidget: WidgetSpec;

package/plugins/citation-plugin/index.d.ts

@@ -0,0 +1,31 @@
+import { Decoration, DecorationSet, EditorState, InlineDecorationSpec, MarkSpec, ProsePlugin, Schema, WidgetSpec } from '@lblod/ember-rdfa-editor';
+import { ProseStore } from '@lblod/ember-rdfa-editor/plugins/datastore';
+export declare const CITATION_REGEX: RegExp;
+export type CitationSchema = Schema<string, 'citation'>;
+export interface CitationDecorationSpec extends InlineDecorationSpec {
+    legislationTypeUri: string;
+    searchText: string;
+}
+export interface CitationDecoration extends Decoration {
+    spec: CitationDecorationSpec;
+}
+interface CitationPluginState {
+    highlights: DecorationSet;
+    activeRanges: [number, number][];
+}
+export type CitationPlugin = ProsePlugin<CitationPluginState>;
+export interface CitationPluginBundle {
+    plugin: ProsePlugin<CitationPluginState>;
+    widgets: {
+        citationCard: WidgetSpec;
+        citationInsert: WidgetSpec;
+    };
+    marks: {
+        citation: MarkSpec;
+    };
+}
+export interface CitationPluginConfig {
+    activeIn?(state: EditorState, datastore: ProseStore): [number, number][];
+}
+export declare function setupCitationPlugin(config?: CitationPluginConfig): CitationPluginBundle;
+export {};

package/plugins/citation-plugin/marks/citation.d.ts

@@ -0,0 +1,2 @@
+import { MarkSpec } from '@lblod/ember-rdfa-editor';
+export declare const citation: MarkSpec;

package/plugins/citation-plugin/utils/cited-text.d.ts

@@ -0,0 +1,3 @@
+import { PNode } from '@lblod/ember-rdfa-editor';
+import { CitationSchema } from '@lblod/ember-rdfa-editor-lblod-plugins/plugins/citation-plugin';
+export declare function citedText(schema: CitationSchema, title: string, uri: string): PNode;

package/plugins/citation-plugin/utils/process-match.d.ts

@@ -0,0 +1,23 @@
+export type RegexpMatchArrayWithIndices = RegExpMatchArray & {
+    indices: Array<[number, number]> & {
+        groups: {
+            [key: string]: [number, number];
+        };
+    };
+};
+interface ProcessedMatch {
+    text: string;
+    legislationTypeUri: string;
+    typeMatch: {
+        text: string;
+        start: number;
+        end: number;
+    } | null;
+    searchTextMatch: {
+        text: string;
+        start: number;
+        end: number;
+    };
+}
+export default function processMatch(match: RegexpMatchArrayWithIndices): ProcessedMatch | null;
+export {};

package/plugins/citation-plugin/utils/vlaamse-codex.d.ts

@@ -0,0 +1,56 @@
+import { Option } from '@lblod/ember-rdfa-editor-lblod-plugins/utils/option';
+import Ember from 'ember';
+import SafeString = Ember.Handlebars.SafeString;
+interface DecisionArgs {
+    uri: string;
+    legislationTypeUri: Option<string>;
+    title: string | null;
+    publicationDate: string | null;
+    documentDate: string | null;
+}
+export declare class Decision {
+    uri: string;
+    legislationType: {
+        label: string;
+        value: string;
+    } | undefined;
+    title: string | null;
+    publicationDate: string | null;
+    documentDate: string | null;
+    constructor({ uri, legislationTypeUri, title, publicationDate, documentDate, }: DecisionArgs);
+    get fullTitle(): string;
+}
+interface ArticleArgs {
+    uri: string;
+    number?: number;
+    content: string | null;
+    dateInForce: string | null;
+    dateNoLongerInForce: string | null;
+}
+export declare class Article {
+    uri: string;
+    number?: number;
+    content: SafeString | null;
+    dateInForce: string | null;
+    dateNoLongerInForce: string | null;
+    constructor({ uri, number, content, dateInForce, dateNoLongerInForce, }: ArticleArgs);
+}
+export interface QueryFilter {
+    type: string;
+    documentDateFrom?: Option<string>;
+    documentDateTo?: Option<string>;
+    publicationDateFrom?: Option<string>;
+    publicationDateTo?: Option<string>;
+}
+declare function fetchDecisions(words: string[], filter: QueryFilter, pageNumber?: number, pageSize?: number): Promise<DecisionCollection>;
+interface DecisionCollection {
+    totalCount: number;
+    decisions: Decision[];
+}
+declare function fetchArticles(legalExpression: string, pageNumber: number, pageSize: number, articleFilter: string): Promise<ArticleCollection>;
+interface ArticleCollection {
+    totalCount: number;
+    articles: Article[];
+}
+declare function cleanCaches(): void;
+export { fetchDecisions, fetchArticles, cleanCaches };

package/plugins/import-snippet-plugin.d.ts

@@ -0,0 +1,2 @@
+import { WidgetSpec } from '@lblod/ember-rdfa-editor';
+export declare const importSnippetWidget: WidgetSpec;

package/plugins/insert-variable-plugin.d.ts

@@ -0,0 +1,2 @@
+import { WidgetSpec } from '@lblod/ember-rdfa-editor';
+export declare function insertVariableWidget(options?: unknown): WidgetSpec;

package/plugins/rdfa-date-plugin.d.ts

@@ -0,0 +1,3 @@
+import { WidgetSpec } from '@lblod/ember-rdfa-editor';
+export declare const rdfaDateCardWidget: WidgetSpec;
+export declare const rdfaDateInsertWidget: WidgetSpec;

package/plugins/roadsign-regulation-plugin.d.ts

@@ -0,0 +1,2 @@
+import { WidgetSpec } from '@lblod/ember-rdfa-editor';
+export declare const roadSignRegulationWidget: WidgetSpec;

package/plugins/standard-template-plugin.d.ts

@@ -0,0 +1,2 @@
+import { WidgetSpec } from '@lblod/ember-rdfa-editor';
+export declare const standardTemplateWidget: WidgetSpec;

package/plugins/table-of-contents-plugin.d.ts

@@ -0,0 +1,3 @@
+import { WidgetSpec } from '@lblod/ember-rdfa-editor';
+import { TableOfContentsConfig } from '../constants';
+export declare function tableOfContentsWidget(config?: TableOfContentsConfig): WidgetSpec;

package/plugins/template-variable-plugin.d.ts

@@ -0,0 +1,2 @@
+import { WidgetSpec } from '@lblod/ember-rdfa-editor';
+export declare const templateVariableWidget: WidgetSpec;

package/services/import-rdfa-snippet.d.ts

@@ -0,0 +1,99 @@
+import Service from '@ember/service';
+import ContextScanner from '@lblod/marawa/rdfa-context-scanner';
+import RdfaBlock from '@lblod/marawa/rdfa-block';
+type RequestParams = {
+    source: string;
+    uri?: string;
+    omitCredentials: boolean | string;
+    mock: boolean | string;
+};
+export declare class RdfaSnippet {
+    readonly source: string;
+    readonly type: string;
+    readonly content: string;
+    readonly blocks: RdfaBlock[];
+    constructor(source: string, type: string, content: string, blocks: RdfaBlock[]);
+}
+type Error = {
+    source: string;
+    details: string;
+};
+/**
+ * Service responsible for fetching and storing a snippet
+ *
+ * Assumptions
+ * -----------
+ *  - one toplevel rdfa block per snippet
+ *
+ * @module editor-import-snippet-plugin
+ * @class ImportRdfaSnippet
+ * @constructor
+ * @extends EmberService
+ */
+export default class ImportRdfaSnippet extends Service {
+    errors: Error[];
+    snippets: RdfaSnippet[];
+    contextScanner: ContextScanner;
+    constructor();
+    /**
+     * Download, processes and stores snippet
+     * @method downloadSnippet
+     * @param {Object}: {source}
+     * @return {String}
+     * @public
+     */
+    downloadSnippet(params: RequestParams): Promise<void>;
+    /**
+     * Remove a snippet from the store, typically after using it
+     * @method removeSnippet
+     * @return void
+     * @public
+     */
+    removeSnippet(snippet: RdfaSnippet): void;
+    /**
+     * Return snippets for a given type, current supported types are 'roadsign' and 'generic'
+     * @method snippetsForType
+     * @params {String} type
+     * @return {Array} array of RdfaSnippets
+     */
+    snippetsForType(type: string): RdfaSnippet[];
+    /**
+     * Fetches snippet from remote
+     * @method processSnippet
+     * @param params.omitCredentials {String} if truthy, the fetch call will omit credentials (this is important for endpoints that only provide simple CORS headers). When not set or falsy we fetch with "include" credentials. This means the endpoint needs to provide the Access-Control-Allow-Credentials and Access-Controlled-Allow-Origin needs to be set to the requesting domain ('*' is not allowed)
+     * @param params.source {String} the URL of the document to fetch
+     * @result {Response} result from ember fetch call
+     * @private
+     */
+    getSnippet(params: RequestParams): Promise<Response | null>;
+    /**
+     * heuristic to determine the type of snippet
+     * currently just a very basic check if a type exists in the snippet.
+     * @method determineType
+     */
+    determineType(rdfaBlocks: RdfaBlock[]): string;
+    /**
+     * Processes and stores snippet
+     * @method processSnippet
+     * @private
+     */
+    processSnippet(params: RequestParams, data: Response): Promise<void>;
+    /**
+     * Make HTML Content Template from string
+     * @method htmlToElement
+     * @param {String}
+     * @return {Object}
+     * @private
+     */
+    htmlToElements(html: string): Element[];
+    /**
+     * Stores snippet
+     * @method storeSnippet
+     * @param {String} source the source url of the snippet
+     * @param {String} content the unparsed text content of the snippet
+     * @param {Array} block array of richnodes representing the content of the snippet
+     * @private
+     */
+    storeSnippet(source: string, type: string, content: string, blocks: RdfaBlock[]): void;
+}
+export {};

package/services/roadsign-registry.d.ts

@@ -0,0 +1,42 @@
+import Service from '@ember/service';
+import Instruction from '../models/instruction';
+import Measure from '../models/measure';
+import Sign from '../models/sign';
+import { IBindings } from 'fetch-sparql-endpoint';
+export default class RoadsignRegistryService extends Service {
+    classifications: {
+        value: string;
+        label: string;
+    }[];
+    instructions: Map<string, Instruction[]>;
+    endpoint: string;
+    imageBaseUrl: string;
+    constructor();
+    loadClassifications: import("ember-concurrency").TaskForAsyncTaskFunction<unknown, () => Promise<void>>;
+    getInstructionsForMeasure: import("ember-concurrency").TaskForAsyncTaskFunction<unknown, (uri: string) => Promise<Instruction[]>>;
+    searchCode: import("ember-concurrency").TaskForAsyncTaskFunction<{
+        restartable: boolean;
+    }, (codeString?: string, category?: string, type?: string, combinedSigns?: string[]) => Promise<{
+        value: string;
+        label: string;
+    }[]>>;
+    executeQuery: import("ember-concurrency").TaskForAsyncTaskFunction<unknown, (query: string) => Promise<{
+        results: {
+            bindings: IBindings[];
+        };
+    }>>;
+    fetchInstructionsForMeasure: import("ember-concurrency").TaskForAsyncTaskFunction<unknown, (uri: string) => Promise<Instruction[]>>;
+    fetchMeasures: import("ember-concurrency").TaskForAsyncTaskFunction<{
+        restartable: boolean;
+    }, ({ zonality, type, codes, category, pageStart, }?: {
+        zonality?: string | undefined;
+        type?: string | undefined;
+        codes?: string[] | undefined;
+        category?: string | undefined;
+        pageStart?: number | undefined;
+    }) => Promise<{
+        measures: Measure[];
+        count: number;
+    }>>;
+    fetchSignsForMeasure: import("ember-concurrency").TaskForAsyncTaskFunction<unknown, (uri: string) => Promise<Sign[]>>;
+}

package/services/standard-template-plugin.d.ts

@@ -0,0 +1,21 @@
+import Store from '@ember-data/store';
+import { DS } from 'ember-data';
+import Service from '@ember/service';
+import { Task } from 'ember-concurrency';
+import TemplateModel from '../models/template';
+export default class StandardTemplatePluginService extends Service {
+    store: Store;
+    templates: DS.RecordArray<TemplateModel>;
+    constructor();
+    fetchTemplates: Task<DS.RecordArray<TemplateModel>, []>;
+    loadTemplates(): Promise<void>;
+    /**
+       Filter the valid templates for a context.
+       @method templatesForContext
+       @param {Array} Array of templates
+       @param {Array} The path of rdfaContext objects from the root till the current context
+       @return {Array} Array of templates (filtered)
+       @private
+    */
+    templatesForContext(templates: TemplateModel[], rdfaTypes: string[]): TemplateModel[];
+}