@lde/pipeline 0.5.1 → 0.6.1

package/README.md

@@ -0,0 +1,44 @@
+# Pipeline
+
+Framework for building RDF data processing pipelines with SPARQL.
+
+## Features
+
+- **Pipeline** — orchestrates steps that process DCAT datasets
+- **PipelineBuilder** — fluent API for constructing pipelines from steps and selectors
+- **PipelineConfig** — load pipeline configuration from YAML/JSON files
+- **SparqlConstructExecutor** — streaming SPARQL CONSTRUCT with template substitution and variable bindings
+- **Distribution analysis** — probe and analyze dataset distributions
+
+## Subpath exports
+
+| Export                   | Description                                                   |
+| ------------------------ | ------------------------------------------------------------- |
+| `@lde/pipeline`          | Steps, pipeline, builder, config, SPARQL                      |
+| `@lde/pipeline/analyzer` | Analyzer contracts (`Analyzer`, `BaseAnalyzer`, result types) |
+| `@lde/pipeline/writer`   | Write RDF data to files or SPARQL endpoints                   |
+
+## Usage
+
+```typescript
+import {
+  PipelineBuilder,
+  SparqlConstructExecutor,
+  collect,
+} from '@lde/pipeline';
+
+// Build a pipeline from steps
+const pipeline = new PipelineBuilder().addStep(myStep).build();
+
+// Or use the SPARQL executor directly
+const executor = new SparqlConstructExecutor({
+  query: 'CONSTRUCT { ?dataset ?p ?o } WHERE { ?s ?p ?o }',
+});
+const result = await executor.execute(dataset);
+```
+
+## Validation
+
+```sh
+npx nx run-many -t lint test typecheck build --projects=@lde/pipeline
+```

package/dist/analyzer.d.ts

@@ -0,0 +1,36 @@
+import { Dataset } from '@lde/dataset';
+import type { DatasetCore } from '@rdfjs/types';
+import { NotSupported } from './step.js';
+export { NotSupported } from './step.js';
+/**
+ * Result of a successful analysis.
+ */
+export declare class Success {
+    readonly data: DatasetCore;
+    constructor(data: DatasetCore);
+}
+/**
+ * Analysis failed.
+ */
+export declare class Failure {
+    readonly endpoint: URL;
+    readonly message?: string | undefined;
+    constructor(endpoint: URL, message?: string | undefined);
+}
+/**
+ * Interface for analyzers.
+ */
+export interface Analyzer {
+    readonly name: string;
+    execute(dataset: Dataset): Promise<Success | Failure | NotSupported>;
+    finish?(): Promise<void>;
+}
+/**
+ * Base class for analyzers with default implementations.
+ */
+export declare abstract class BaseAnalyzer implements Analyzer {
+    abstract readonly name: string;
+    abstract execute(dataset: Dataset): Promise<Success | Failure | NotSupported>;
+    finish(): Promise<void>;
+}
+//# sourceMappingURL=analyzer.d.ts.map

package/dist/analyzer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"analyzer.d.ts","sourceRoot":"","sources":["../src/analyzer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAC;AACvC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAChD,OAAO,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AAEzC,OAAO,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AAEzC;;GAEG;AACH,qBAAa,OAAO;aACU,IAAI,EAAE,WAAW;gBAAjB,IAAI,EAAE,WAAW;CAC9C;AAED;;GAEG;AACH,qBAAa,OAAO;aAEA,QAAQ,EAAE,GAAG;aACb,OAAO,CAAC,EAAE,MAAM;gBADhB,QAAQ,EAAE,GAAG,EACb,OAAO,CAAC,EAAE,MAAM,YAAA;CAEnC;AAED;;GAEG;AACH,MAAM,WAAW,QAAQ;IACvB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,OAAO,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,OAAO,GAAG,OAAO,GAAG,YAAY,CAAC,CAAC;IACrE,MAAM,CAAC,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CAC1B;AAED;;GAEG;AACH,8BAAsB,YAAa,YAAW,QAAQ;IACpD,QAAQ,CAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,OAAO,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,OAAO,GAAG,OAAO,GAAG,YAAY,CAAC;IAEvE,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC;CAG9B"}

package/dist/analyzer.js

@@ -0,0 +1,29 @@
+export { NotSupported } from './step.js';
+/**
+ * Result of a successful analysis.
+ */
+export class Success {
+    data;
+    constructor(data) {
+        this.data = data;
+    }
+}
+/**
+ * Analysis failed.
+ */
+export class Failure {
+    endpoint;
+    message;
+    constructor(endpoint, message) {
+        this.endpoint = endpoint;
+        this.message = message;
+    }
+}
+/**
+ * Base class for analyzers with default implementations.
+ */
+export class BaseAnalyzer {
+    async finish() {
+        // Default no-op implementation.
+    }
+}

package/dist/builder.d.ts

@@ -0,0 +1,114 @@
+import { Selector, ManualDatasetSelection, RegistrySelector } from './selector.js';
+import { Step } from './step.js';
+/**
+ * Configuration for QLever SPARQL server.
+ */
+export interface QleverConfig {
+    /**
+     * Execution mode: 'docker' for containerized, 'native' for local binary.
+     */
+    mode: 'docker' | 'native';
+    /**
+     * Docker image to use (for docker mode).
+     * @default 'adfreiburg/qlever'
+     */
+    image?: string;
+    /**
+     * Port for the SPARQL endpoint.
+     * @default 7001
+     */
+    port?: number;
+    /**
+     * Working directory for imports.
+     */
+    workingDir?: string;
+}
+/**
+ * Writer configuration.
+ */
+export interface WriterConfig {
+    type: 'file' | 'sparql';
+    outputDir?: string;
+    endpoint?: URL;
+}
+/**
+ * Complete pipeline configuration.
+ */
+export interface PipelineConfig {
+    selector: Selector;
+    steps: Step[];
+    writers?: WriterConfig[];
+    qlever?: QleverConfig;
+}
+/**
+ * Fluent builder for creating pipeline configurations.
+ *
+ * @example
+ * ```typescript
+ * const config = PipelineBuilder.create()
+ *   .withSelector(registry('https://example.com/sparql'))
+ *   .addStep(sparqlQuery('queries/triples.rq'))
+ *   .addWriter(fileWriter({ outputDir: 'output' }))
+ *   .build();
+ * ```
+ */
+export declare class PipelineBuilder {
+    private selector?;
+    private steps;
+    private writers;
+    private qleverConfig?;
+    /**
+     * Create a new PipelineBuilder instance.
+     */
+    static create(): PipelineBuilder;
+    /**
+     * Set the dataset selector.
+     */
+    withSelector(selector: Selector): this;
+    /**
+     * Configure QLever for local SPARQL imports.
+     */
+    withQlever(config: QleverConfig): this;
+    /**
+     * Add a single step to the pipeline.
+     */
+    addStep(step: Step): this;
+    /**
+     * Add multiple steps to the pipeline.
+     */
+    addSteps(...steps: Step[]): this;
+    /**
+     * Add a writer for pipeline output.
+     */
+    addWriter(writer: WriterConfig): this;
+    /**
+     * Build the final pipeline configuration.
+     * @throws Error if selector is not set
+     */
+    build(): PipelineConfig;
+}
+/**
+ * Create a selector that queries a Dataset Registry.
+ *
+ * @param endpoint SPARQL endpoint URL of the registry
+ */
+export declare function registry(endpoint: string | URL): RegistrySelector;
+/**
+ * Create a selector for manually specified datasets.
+ *
+ * @param datasets Array of dataset IRIs
+ */
+export declare function manual(...datasetIris: URL[]): ManualDatasetSelection;
+/**
+ * Create a file writer configuration.
+ */
+export declare function fileWriter(options: {
+    outputDir: string;
+}): WriterConfig;
+/**
+ * Create a SPARQL UPDATE writer configuration.
+ */
+export declare function sparqlWriter(options: {
+    endpoint: URL;
+}): WriterConfig;
+//# sourceMappingURL=builder.d.ts.map

package/dist/builder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"builder.d.ts","sourceRoot":"","sources":["../src/builder.ts"],"names":[],"mappings":"AACA,OAAO,EACL,QAAQ,EACR,sBAAsB,EACtB,gBAAgB,EACjB,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAGjC;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B;;OAEG;IACH,IAAI,EAAE,QAAQ,GAAG,QAAQ,CAAC;IAC1B;;;OAGG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;IACf;;;OAGG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC;IACd;;OAEG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;AAED;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,MAAM,GAAG,QAAQ,CAAC;IACxB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,QAAQ,CAAC,EAAE,GAAG,CAAC;CAChB;AAED;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,QAAQ,EAAE,QAAQ,CAAC;IACnB,KAAK,EAAE,IAAI,EAAE,CAAC;IACd,OAAO,CAAC,EAAE,YAAY,EAAE,CAAC;IACzB,MAAM,CAAC,EAAE,YAAY,CAAC;CACvB;AAED;;;;;;;;;;;GAWG;AACH,qBAAa,eAAe;IAC1B,OAAO,CAAC,QAAQ,CAAC,CAAW;IAC5B,OAAO,CAAC,KAAK,CAAc;IAC3B,OAAO,CAAC,OAAO,CAAsB;IACrC,OAAO,CAAC,YAAY,CAAC,CAAe;IAEpC;;OAEG;IACH,MAAM,CAAC,MAAM,IAAI,eAAe;IAIhC;;OAEG;IACH,YAAY,CAAC,QAAQ,EAAE,QAAQ,GAAG,IAAI;IAKtC;;OAEG;IACH,UAAU,CAAC,MAAM,EAAE,YAAY,GAAG,IAAI;IAKtC;;OAEG;IACH,OAAO,CAAC,IAAI,EAAE,IAAI,GAAG,IAAI;IAKzB;;OAEG;IACH,QAAQ,CAAC,GAAG,KAAK,EAAE,IAAI,EAAE,GAAG,IAAI;IAKhC;;OAEG;IACH,SAAS,CAAC,MAAM,EAAE,YAAY,GAAG,IAAI;IAKrC;;;OAGG;IACH,KAAK,IAAI,cAAc;CAYxB;AAID;;;;GAIG;AACH,wBAAgB,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,GAAG,GAAG,gBAAgB,CAMjE;AAED;;;;GAIG;AACH,wBAAgB,MAAM,CAAC,GAAG,WAAW,EAAE,GAAG,EAAE,GAAG,sBAAsB,CAKpE;AAED;;GAEG;AACH,wBAAgB,UAAU,CAAC,OAAO,EAAE;IAAE,SAAS,EAAE,MAAM,CAAA;CAAE,GAAG,YAAY,CAKvE;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE;IAAE,QAAQ,EAAE,GAAG,CAAA;CAAE,GAAG,YAAY,CAKrE"}

package/dist/builder.js

@@ -0,0 +1,115 @@
+import { Dataset } from '@lde/dataset';
+import { ManualDatasetSelection, RegistrySelector, } from './selector.js';
+import { Client } from '@lde/dataset-registry-client';
+/**
+ * Fluent builder for creating pipeline configurations.
+ *
+ * @example
+ * ```typescript
+ * const config = PipelineBuilder.create()
+ *   .withSelector(registry('https://example.com/sparql'))
+ *   .addStep(sparqlQuery('queries/triples.rq'))
+ *   .addWriter(fileWriter({ outputDir: 'output' }))
+ *   .build();
+ * ```
+ */
+export class PipelineBuilder {
+    selector;
+    steps = [];
+    writers = [];
+    qleverConfig;
+    /**
+     * Create a new PipelineBuilder instance.
+     */
+    static create() {
+        return new PipelineBuilder();
+    }
+    /**
+     * Set the dataset selector.
+     */
+    withSelector(selector) {
+        this.selector = selector;
+        return this;
+    }
+    /**
+     * Configure QLever for local SPARQL imports.
+     */
+    withQlever(config) {
+        this.qleverConfig = config;
+        return this;
+    }
+    /**
+     * Add a single step to the pipeline.
+     */
+    addStep(step) {
+        this.steps.push(step);
+        return this;
+    }
+    /**
+     * Add multiple steps to the pipeline.
+     */
+    addSteps(...steps) {
+        this.steps.push(...steps);
+        return this;
+    }
+    /**
+     * Add a writer for pipeline output.
+     */
+    addWriter(writer) {
+        this.writers.push(writer);
+        return this;
+    }
+    /**
+     * Build the final pipeline configuration.
+     * @throws Error if selector is not set
+     */
+    build() {
+        if (!this.selector) {
+            throw new Error('Selector is required. Use withSelector() to set it.');
+        }
+        return {
+            selector: this.selector,
+            steps: this.steps,
+            writers: this.writers.length > 0 ? this.writers : undefined,
+            qlever: this.qleverConfig,
+        };
+    }
+}
+// Helper functions for fluent construction.
+/**
+ * Create a selector that queries a Dataset Registry.
+ *
+ * @param endpoint SPARQL endpoint URL of the registry
+ */
+export function registry(endpoint) {
+    return new RegistrySelector({
+        registry: new Client(typeof endpoint === 'string' ? new URL(endpoint) : endpoint),
+    });
+}
+/**
+ * Create a selector for manually specified datasets.
+ *
+ * @param datasets Array of dataset IRIs
+ */
+export function manual(...datasetIris) {
+    const datasets = datasetIris.map((iri) => new Dataset({ iri, distributions: [] }));
+    return new ManualDatasetSelection(datasets);
+}
+/**
+ * Create a file writer configuration.
+ */
+export function fileWriter(options) {
+    return {
+        type: 'file',
+        outputDir: options.outputDir,
+    };
+}
+/**
+ * Create a SPARQL UPDATE writer configuration.
+ */
+export function sparqlWriter(options) {
+    return {
+        type: 'sparql',
+        endpoint: options.endpoint,
+    };
+}

package/dist/config.d.ts

@@ -0,0 +1,70 @@
+import { PipelineConfig, QleverConfig } from './builder.js';
+/**
+ * Raw configuration schema from YAML/JSON files.
+ */
+export interface RawPipelineConfig {
+    selector?: {
+        type: 'registry' | 'manual';
+        endpoint?: string;
+        datasets?: string[];
+    };
+    qlever?: QleverConfig;
+    steps?: Array<{
+        type: 'sparql-query';
+        query: string;
+    }>;
+    writers?: Array<{
+        type: 'file' | 'sparql';
+        outputDir?: string;
+        endpoint?: string;
+    }>;
+}
+/**
+ * Options for loading pipeline configuration.
+ */
+export interface LoadConfigOptions {
+    /**
+     * Configuration file name (without extension).
+     * @default 'pipeline.config'
+     */
+    name?: string;
+    /**
+     * Working directory to search for config files.
+     * @default process.cwd()
+     */
+    cwd?: string;
+}
+/**
+ * Define a pipeline configuration with TypeScript type checking.
+ *
+ * @example
+ * ```typescript
+ * // pipeline.config.ts
+ * import { defineConfig } from '@lde/pipeline';
+ *
+ * export default defineConfig({
+ *   selector: { type: 'registry', endpoint: 'https://example.com/sparql' },
+ *   steps: [{ type: 'sparql-query', query: 'queries/triples.rq' }],
+ * });
+ * ```
+ */
+export declare function defineConfig(config: RawPipelineConfig): RawPipelineConfig;
+/**
+ * Load pipeline configuration from files.
+ *
+ * Searches for configuration files in the following order:
+ * - pipeline.config.ts
+ * - pipeline.config.js
+ * - pipeline.config.yaml
+ * - pipeline.config.yml
+ * - pipeline.config.json
+ *
+ * @param options Load options
+ * @returns Resolved pipeline configuration
+ */
+export declare function loadPipelineConfig(options?: LoadConfigOptions): Promise<PipelineConfig>;
+/**
+ * Normalize raw configuration into a typed PipelineConfig.
+ */
+export declare function normalizeConfig(raw: RawPipelineConfig): PipelineConfig;
+//# sourceMappingURL=config.d.ts.map

package/dist/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AACA,OAAO,EACL,cAAc,EACd,YAAY,EAIb,MAAM,cAAc,CAAC;AAKtB;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,EAAE;QACT,IAAI,EAAE,UAAU,GAAG,QAAQ,CAAC;QAC5B,QAAQ,CAAC,EAAE,MAAM,CAAC;QAClB,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;KACrB,CAAC;IACF,MAAM,CAAC,EAAE,YAAY,CAAC;IACtB,KAAK,CAAC,EAAE,KAAK,CAAC;QACZ,IAAI,EAAE,cAAc,CAAC;QACrB,KAAK,EAAE,MAAM,CAAC;KACf,CAAC,CAAC;IACH,OAAO,CAAC,EAAE,KAAK,CAAC;QACd,IAAI,EAAE,MAAM,GAAG,QAAQ,CAAC;QACxB,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,QAAQ,CAAC,EAAE,MAAM,CAAC;KACnB,CAAC,CAAC;CACJ;AAED;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC;;;OAGG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC;IACd;;;OAGG;IACH,GAAG,CAAC,EAAE,MAAM,CAAC;CACd;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,iBAAiB,GAAG,iBAAiB,CAEzE;AAED;;;;;;;;;;;;GAYG;AACH,wBAAsB,kBAAkB,CACtC,OAAO,CAAC,EAAE,iBAAiB,GAC1B,OAAO,CAAC,cAAc,CAAC,CAWzB;AAED;;GAEG;AACH,wBAAgB,eAAe,CAAC,GAAG,EAAE,iBAAiB,GAAG,cAAc,CAOtE"}

package/dist/config.js

@@ -0,0 +1,110 @@
+import { loadConfig } from 'c12';
+import { registry, manual, } from './builder.js';
+import { SparqlQuery } from './step/sparqlQuery.js';
+/**
+ * Define a pipeline configuration with TypeScript type checking.
+ *
+ * @example
+ * ```typescript
+ * // pipeline.config.ts
+ * import { defineConfig } from '@lde/pipeline';
+ *
+ * export default defineConfig({
+ *   selector: { type: 'registry', endpoint: 'https://example.com/sparql' },
+ *   steps: [{ type: 'sparql-query', query: 'queries/triples.rq' }],
+ * });
+ * ```
+ */
+export function defineConfig(config) {
+    return config;
+}
+/**
+ * Load pipeline configuration from files.
+ *
+ * Searches for configuration files in the following order:
+ * - pipeline.config.ts
+ * - pipeline.config.js
+ * - pipeline.config.yaml
+ * - pipeline.config.yml
+ * - pipeline.config.json
+ *
+ * @param options Load options
+ * @returns Resolved pipeline configuration
+ */
+export async function loadPipelineConfig(options) {
+    const { config } = await loadConfig({
+        name: options?.name ?? 'pipeline.config',
+        cwd: options?.cwd,
+    });
+    if (!config) {
+        throw new Error('No pipeline configuration found');
+    }
+    return normalizeConfig(config);
+}
+/**
+ * Normalize raw configuration into a typed PipelineConfig.
+ */
+export function normalizeConfig(raw) {
+    return {
+        selector: normalizeSelector(raw.selector),
+        steps: normalizeSteps(raw.steps),
+        writers: normalizeWriters(raw.writers),
+        qlever: raw.qlever,
+    };
+}
+function normalizeSelector(raw) {
+    if (!raw) {
+        throw new Error('Selector configuration is required');
+    }
+    switch (raw.type) {
+        case 'registry':
+            if (!raw.endpoint) {
+                throw new Error('Registry selector requires endpoint');
+            }
+            return registry(raw.endpoint);
+        case 'manual':
+            if (!raw.datasets || raw.datasets.length === 0) {
+                throw new Error('Manual selector requires datasets');
+            }
+            return manual(...raw.datasets.map((d) => new URL(d)));
+        default:
+            throw new Error(`Unknown selector type: ${raw.type}`);
+    }
+}
+function normalizeSteps(raw) {
+    if (!raw) {
+        return [];
+    }
+    return raw.map((step) => {
+        switch (step.type) {
+            case 'sparql-query':
+                return new SparqlQuery({
+                    identifier: step.query,
+                    query: step.query, // Will be loaded from file by SparqlQuery.fromFile if path
+                });
+            default:
+                throw new Error(`Unknown step type: ${step.type}`);
+        }
+    });
+}
+function normalizeWriters(raw) {
+    if (!raw || raw.length === 0) {
+        return undefined;
+    }
+    return raw.map((writer) => {
+        switch (writer.type) {
+            case 'file':
+                if (!writer.outputDir) {
+                    throw new Error('File writer requires outputDir');
+                }
+                return { type: 'file', outputDir: writer.outputDir };
+            case 'sparql':
+                if (!writer.endpoint) {
+                    throw new Error('SPARQL writer requires endpoint');
+                }
+                return { type: 'sparql', endpoint: new URL(writer.endpoint) };
+            default:
+                throw new Error(`Unknown writer type: ${writer.type}`);
+        }
+    });
+}

package/dist/distribution/analyzer.d.ts

@@ -0,0 +1,58 @@
+import { Dataset } from '@lde/dataset';
+import { Importer, ImportFailed, ImportSuccessful, NotSupported } from '@lde/sparql-importer';
+import { Store } from 'n3';
+export type { Importer };
+export { ImportFailed, ImportSuccessful, NotSupported };
+/**
+ * Extended importer interface with optional cleanup method.
+ */
+export interface ImporterWithFinish extends Importer {
+    finish?(): Promise<void>;
+}
+export interface DistributionAnalyzerOptions {
+    /**
+     * Optional importer for loading data dumps when no SPARQL endpoint is available.
+     */
+    importer?: ImporterWithFinish;
+    /**
+     * Timeout for probe requests in milliseconds.
+     * @default 5000
+     */
+    timeout?: number;
+}
+/**
+ * Result indicating the analyzer could not find a usable distribution.
+ */
+export declare class NoDistributionAvailable {
+    readonly message: string;
+    constructor(message: string);
+}
+/**
+ * Analyzes dataset distributions by probing their availability.
+ *
+ * - Probes SPARQL endpoints with a simple SELECT query
+ * - Probes data dumps with HEAD/GET requests
+ * - Records probe results as RDF (schema:Action)
+ * - Updates distribution metadata (isValid, lastModified, byteSize)
+ * - Optionally imports data dumps if no SPARQL endpoint is available
+ */
+export declare class DistributionAnalyzer {
+    readonly name = "distribution";
+    private readonly importer?;
+    private readonly timeout;
+    constructor(options?: DistributionAnalyzerOptions);
+    /**
+     * Analyze all distributions of a dataset.
+     *
+     * @returns Store with probe results as RDF, or NoDistributionAvailable if no usable distribution found
+     */
+    execute(dataset: Dataset): Promise<Store | NoDistributionAvailable>;
+    /**
+     * Cleanup resources (e.g., importer connections).
+     */
+    finish(): Promise<void>;
+    private buildProbeResultsRdf;
+    private addSuccessTriples;
+    private addImportError;
+}
+//# sourceMappingURL=analyzer.d.ts.map

package/dist/distribution/analyzer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"analyzer.d.ts","sourceRoot":"","sources":["../../src/distribution/analyzer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAgB,MAAM,cAAc,CAAC;AACrD,OAAO,EACL,QAAQ,EACR,YAAY,EACZ,gBAAgB,EAChB,YAAY,EACb,MAAM,sBAAsB,CAAC;AAC9B,OAAO,EAAe,KAAK,EAAE,MAAM,IAAI,CAAC;AASxC,YAAY,EAAE,QAAQ,EAAE,CAAC;AACzB,OAAO,EAAE,YAAY,EAAE,gBAAgB,EAAE,YAAY,EAAE,CAAC;AAWxD;;GAEG;AACH,MAAM,WAAW,kBAAmB,SAAQ,QAAQ;IAClD,MAAM,CAAC,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CAC1B;AAED,MAAM,WAAW,2BAA2B;IAC1C;;OAEG;IACH,QAAQ,CAAC,EAAE,kBAAkB,CAAC;IAE9B;;;OAGG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED;;GAEG;AACH,qBAAa,uBAAuB;aACN,OAAO,EAAE,MAAM;gBAAf,OAAO,EAAE,MAAM;CAC5C;AAED;;;;;;;;GAQG;AACH,qBAAa,oBAAoB;IAC/B,SAAgB,IAAI,kBAAkB;IACtC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAqB;IAC/C,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAS;gBAErB,OAAO,CAAC,EAAE,2BAA2B;IAKjD;;;;OAIG;IACG,OAAO,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,KAAK,GAAG,uBAAuB,CAAC;IAmCzE;;OAEG;IACG,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC;IAI7B,OAAO,CAAC,oBAAoB;IAwC5B,OAAO,CAAC,iBAAiB;IAiDzB,OAAO,CAAC,cAAc;CAevB"}