Command Line Interface

rdfsolve automatically installs the command rdfsolve. See rdfsolve --help for usage details.

rdfsolve

RDFSolve - RDF Schema Extraction, Export and Analysis Toolkit.

Mining commands:

rdfsolve discover      Discover VoID descriptions from remote endpoints
rdfsolve mine          Mine schemas from remote SPARQL endpoints
rdfsolve local-mine    Mine from a local QLever endpoint
rdfsolve qleverfile    Generate Qleverfiles for QLever

Export commands:

rdfsolve export    Interconvert schemas (JSON-LD, LinkML, SHACL, CSV, ...)

Mapping commands:

rdfsolve instance-match   Cross-dataset class matching
rdfsolve semra            Import external SeMRA mappings
rdfsolve inference        Derive new mappings from existing ones

Usage

rdfsolve [OPTIONS] COMMAND [ARGS]...

Options

--version: Show the version and exit.

-v, --verbose: Enable verbose logging

bioregistry-enrich

Enrich sources.yaml with Bioregistry metadata in-place.

Reads the sources YAML, resolves the canonical Bioregistry prefix for each entry, and writes the resolved bioregistry_* fields back into the file, preserving existing keys and order.

Usage

rdfsolve bioregistry-enrich [OPTIONS]

Options

-s, --sources <sources>

Path to sources YAML file.

Default:: 'data/sources.yaml'

--dry-run: Print resolved prefixes but do not write the file.

-n, --name <names>: Only process entries whose ‘name’ matches (repeatable).

build-graphs

Select canonical schemas and build dataset-level connectivity graphs.

Performs pipeline step 4b (schema selection) and step 12 (graph construction). Exports edge/node Parquet tables, strategy/predicate counts, and metadata.json.

Usage

rdfsolve build-graphs [OPTIONS]

Options

--schemas-dir <schemas_dir>

Root schemas directory.

Default:: 'docker/schemas'

--mappings-dir <mappings_dir>

Root mappings directory.

Default:: 'docker/mappings'

--output-dir <output_dir>

paper_data output root.

Default:: 'results/paper_data'

--datasets <datasets>: Only process these dataset names (shell-style globs, repeatable).

--schema-only: Run schema selection only; skip graph construction.

--no-copy-schemas: Skip copying selected schemas to output-dir/schemas/.

discover

Discover existing VoID descriptions from remote endpoints.

Queries every source endpoint for pre-existing VoID partitions and exports VoID / JSON-LD / LinkML / SHACL artefacts.

Examples:

rdfsolve discover
rdfsolve discover --filter "chembl|drugbank"
rdfsolve discover --output-dir ./discovered

Usage

rdfsolve discover [OPTIONS]

Options

--benchmark: Collect per-run benchmarks (timing, memory, CPU).

--filter <name_filter>: Regex to select sources by name.

--timeout <timeout>: HTTP timeout per SPARQL request (seconds).

--format <fmt>

Export format.

Options:: jsonld | void | all

--output-dir <output_dir>: Output directory for schemas/reports.

--sources <sources>: Path to sources YAML/JSON-LD/CSV.

export

Convert RDF schemas between formats.

All subcommands accept a VoID Turtle (.ttl) or rdfsolve JSON-LD (.jsonld) file as INPUT and produce the requested output format. The input format is auto-detected from the file extension.

Supported conversions (any-to-any via the internal model):

VoID (.ttl)      <->  JSON-LD (.jsonld)
JSON-LD (.jsonld) ->  CSV, LinkML, SHACL, RDF-config, VoID

Subcommands:

csv        Export schema patterns as a CSV table
jsonld     Export schema as JSON-LD
void       Export schema as VoID Turtle
linkml     Export schema as LinkML YAML
shacl      Export schema as SHACL shapes (Turtle)
rdfconfig  Export schema as RDF-config YAML files

Examples:

rdfsolve export csv       dataset_schema.jsonld
rdfsolve export linkml    dataset_void.ttl -o ./out
rdfsolve export shacl     dataset_schema.jsonld --closed
rdfsolve export rdfconfig dataset_void.ttl --endpoint-url http://...
rdfsolve export void      dataset_schema.jsonld

Usage

rdfsolve export [OPTIONS] COMMAND [ARGS]...

csv

Export schema patterns as a CSV table.

Example:

rdfsolve export csv dataset_schema.jsonld -o ./exports

Usage

rdfsolve export csv [OPTIONS] INPUT

Options

-o, --output-dir <output_dir>: Output directory.

Arguments

INPUT: Required argument

jsonld

Export schema as JSON-LD.

Useful for converting a VoID Turtle file into the rdfsolve JSON-LD format. If the input is already JSON-LD, it is re-serialised (which can be used to refresh @about metadata).

Example:

rdfsolve export jsonld dataset_void.ttl -o ./exports

Usage

rdfsolve export jsonld [OPTIONS] INPUT

Options

-o, --output-dir <output_dir>: Output directory.

--endpoint-url <endpoint_url>: SPARQL endpoint URL for @about.

--graph-uri <graph_uri>: Named graph URI for @about.

Arguments

INPUT: Required argument

linkml

Export schema as LinkML YAML.

Generates a LinkML schema definition for data modelling, validation, and code generation.

Example:

rdfsolve export linkml dataset_schema.jsonld --schema-name myds

Usage

rdfsolve export linkml [OPTIONS] INPUT

Options

-o, --output-dir <output_dir>: Output directory.

--schema-name <schema_name>: Schema name (default: from filename).

--schema-description <schema_description>: Schema description.

--schema-uri <schema_uri>: Base URI for the schema (e.g. http://example.org/schemas/myschema).

Arguments

INPUT: Required argument

rdfconfig

Export schema as RDF-config YAML files.

RDF-config is a schema standard for describing RDF data models. Produces a {dataset}_config/ directory with model.yaml, prefix.yaml, and optionally endpoint.yaml.

Example:

rdfsolve export rdfconfig dataset_void.ttl \
    --endpoint-url https://example.org/sparql

Usage

rdfsolve export rdfconfig [OPTIONS] INPUT

Options

-o, --output-dir <output_dir>: Output directory.

--endpoint-url <endpoint_url>: SPARQL endpoint URL (generates endpoint.yaml when provided).

--endpoint-name <endpoint_name>: Endpoint name (default: ‘endpoint’).

--graph-uri <graph_uri>: Named graph URI.

Arguments

INPUT: Required argument

shacl

Export schema as SHACL shapes (Turtle).

SHACL shapes validate RDF data against the extracted schema. Use –closed (default) for strict validation or –open for flexible.

Examples:

rdfsolve export shacl dataset_schema.jsonld --open
rdfsolve export shacl dataset_schema.jsonld --suffix Shape

Usage

rdfsolve export shacl [OPTIONS] INPUT

Options

-o, --output-dir <output_dir>: Output directory.

--schema-name <schema_name>: Schema name (default: from filename).

--schema-description <schema_description>: Schema description.

--schema-uri <schema_uri>: Base URI for the schema.

--closed, --open: Generate closed shapes (default) or open shapes.

--suffix <suffix>: Suffix for shape names (e.g. ‘Shape’ -> PersonShape).

Arguments

INPUT: Required argument

void

Export schema as VoID Turtle.

Converts a JSON-LD schema back to VoID RDF (Turtle). Also works with VoID input (round-trip).

Example:

rdfsolve export void dataset_schema.jsonld -o ./exports

Usage

rdfsolve export void [OPTIONS] INPUT

Options

-o, --output-dir <output_dir>: Output directory.

Arguments

INPUT: Required argument

inference

Derive new mappings from existing ones.

Uses SeMRA inference operations (inversion, transitivity, generalisation) to expand a set of mapping JSON-LD files.

Typical workflow:

rdfsolve inference run --input file1.jsonld file2.jsonld \
    --output docker/mappings/inferenced/inferred.jsonld
rdfsolve inference seed

Usage

rdfsolve inference [OPTIONS] COMMAND [ARGS]...

run

Infer new mappings from the given input files.

Usage

rdfsolve inference run [OPTIONS]

Options

-i, --input <input_paths>: Required Input mapping JSON-LD file (repeatable).

-o, --output <output_path>: Required Output JSON-LD file path.

--no-inversion: Disable inversion inference.

--no-transitivity: Disable transitivity (chain) inference.

--generalisation: Enable generalisation inference (off by default).

--chain-cutoff <chain_cutoff>

Maximum chain length for transitivity.

Default:: 3

--name <dataset_name>: Override @about.dataset_name in the output.

seed

Infer over all mappings found under INPUT_DIR.

Usage

rdfsolve inference seed [OPTIONS]

Options

--input-dir <input_dir>

Directory containing instance_matching/ and semra/ subdirs.

Default:: 'docker/mappings'

--output-dir <output_dir>

Directory for the inferenced output.

Default:: 'docker/mappings/inferenced'

--name <output_name>

Output file stem (without .jsonld).

Default:: 'inferenced_mappings'

--no-inversion: Disable inversion inference.

--no-transitivity: Disable transitivity inference.

--generalisation: Enable generalisation inference.

--chain-cutoff <chain_cutoff>

Maximum chain length for transitivity.

Default:: 3

instance-match

Instance-based matching: discover cross-dataset class links.

Probes SPARQL endpoints for classes whose instances match bioregistry URI patterns and writes skos:narrowMatch mapping JSON-LD files.

Typical workflow:

rdfsolve instance-match probe --prefix ensembl -o ensembl_mapping.jsonld
rdfsolve instance-match seed  --prefixes ensembl uniprot chebi

Usage

rdfsolve instance-match [OPTIONS] COMMAND [ARGS]...

derive

Derive class-level mappings from instance-mapping files.

Usage

rdfsolve instance-match derive [OPTIONS]

Options

-i, --input <input_paths>: Required Input instance-mapping JSON-LD file (repeatable).

-o, --output <output_path>: Required Output JSON-LD file for class-derived mappings.

-e, --endpoint <endpoint_url>: SPARQL / QLever endpoint URL for class lookup (single-endpoint mode).

--ports-json <ports_json_path>: Path to ports.json for multi-endpoint mode (one QLever per dataset).

--batch-size <batch_size>

Number of IRIs per VALUES query.

Default:: 50

--timeout <timeout>

Per-request SPARQL timeout in seconds.

Default:: 60.0

--min-count <min_instance_count>

Minimum instance pairs to retain a class pair.

Default:: 1

--min-confidence <min_confidence>

Minimum confidence score to retain a class pair.

Default:: 0.0

--cache-index: Cache the class index to disk and reuse on subsequent runs.

--index-cache-path <index_cache_path>: Explicit path for the cached index JSON. Defaults to {output}.class_index_cache.json.

--enrich: Write enriched copies of input files alongside the originals ({stem}.enriched.jsonld).

--name <source_name>: Human-readable name for the session report. Defaults to the output file stem.

discover-prefixes

Discover entity prefixes from mapping JSON-LD files.

Scans the given directories for *.jsonld files, extracts all unique entity CURIE prefixes (e.g. ‘mesh’, ‘chebi’, ‘ensembl’), validates them against bioregistry, and prints the sorted list. Use this to dynamically determine the –prefixes list for instance-match seed.

Example:

rdfsolve instance-match discover-prefixes \
    -d output/mappings/sssom \
    -d output/mappings/semra

Usage

rdfsolve instance-match discover-prefixes [OPTIONS]

Options

-d, --mapping-dir <mapping_dirs>: Required Directory to scan for JSON-LD mapping files (repeatable). Pass each of sssom/, semra/, instance_matching/ etc.

-o, --output <output>: Write prefix list to this file (one per line). Default: stdout.

probe

Probe endpoints for a single bioregistry resource.

Queries every endpoint in SOURCES for RDF classes whose instances match the URI patterns registered in bioregistry for PREFIX and emits a JSON-LD mapping document.

Usage

rdfsolve instance-match probe [OPTIONS]

Options

-p, --prefix <prefix>: Required Bioregistry prefix to probe (e.g. ‘ensembl’).

--sources <sources>: Path to sources file (JSON-LD or CSV). Default: auto-detect data/sources.jsonld.

--predicate <predicate>

Mapping predicate URI.

Default:: 'http://www.w3.org/2004/02/skos/core#narrowMatch'

-d, --dataset <datasets>: Restrict to this dataset name (repeatable).

--timeout <timeout>

SPARQL request timeout in seconds.

Default:: 60.0

--delay <inter_request_delay>

Seconds to sleep between successive SPARQL requests to the same endpoint. Set >0 for public remote endpoints; leave 0 for local QLever.

Default:: 0.0

-o, --output <output>: Write JSON-LD to this file (default: stdout).

seed

Seed mapping files for multiple bioregistry resources.

Writes {PREFIX}_instance_mapping.jsonld to OUTPUT_DIR for each supplied PREFIX. Existing files are skipped unless –no-skip-existing is passed.

Use –delay for public remote endpoints to avoid overwhelming them. When –ports-json is given (local QLever), –delay defaults to 0.

Usage

rdfsolve instance-match seed [OPTIONS]

Options

-p, --prefixes <prefix_list>: Required Bioregistry prefix (repeatable).

--sources <sources>: Path to sources file (JSON-LD or CSV). Default: auto-detect data/sources.jsonld.

--output-dir <output_dir>

Directory to write JSON-LD mapping files.

Default:: 'docker/mappings/instance_matching'

--predicate <predicate>

Mapping predicate URI.

Default:: 'http://www.w3.org/2004/02/skos/core#narrowMatch'

-d, --dataset <datasets>: Restrict to this dataset name (repeatable).

--timeout <timeout>

SPARQL request timeout in seconds.

Default:: 60.0

--no-skip-existing: Re-probe even if the output file already exists.

--ports-json <ports_json>: Path to QLever ports.json ({name: port}). When supplied, queries go to local QLever endpoints instead of remote SPARQL.

--delay <inter_request_delay>

Seconds to sleep between successive SPARQL requests to the same endpoint. Set >0 (e.g. 2.0) for public remote endpoints; leave 0 for local QLever.

Default:: 0.0

local-mine

Mine schemas from a local QLever endpoint.

Use after downloading data and running qlever index && qlever start for a dataset.

Examples:

rdfsolve local-mine --name drugbank \
    --endpoint http://localhost:7026 --discover-first
rdfsolve local-mine --test

Usage

rdfsolve local-mine [OPTIONS]

Options

--benchmark: Collect per-run benchmarks (timing, memory, CPU).

--filter <name_filter>: Regex to select sources by name.

--timeout <timeout>: HTTP timeout per SPARQL request (seconds).

--format <fmt>

Export format.

Options:: jsonld | void | all

--output-dir <output_dir>: Output directory for schemas/reports.

--sources <sources>: Path to sources YAML/JSON-LD/CSV.

--one-shot: Mine using a single unbounded SELECT per pattern type (no LIMIT/OFFSET, no fallback chain). Recommended for local QLever endpoints.

--author <NAME|ORCID>: Credit an author in provenance metadata. Format: ‘Full Name|0000-0000-0000-0000’. ORCID is optional. Repeat for multiple authors.

--untyped-as-classes: Treat untyped URI objects as owl:Class references.

--no-counts: Skip triple-count queries (faster).

--class-batch-size <class_batch_size>: Classes per VALUES query in two-phase mining.

--class-chunk-size <class_chunk_size>: Page size for Phase-1 class discovery (two-phase mode only). Default: no pagination.

--chunk-size <chunk_size>: SPARQL pagination page size.

--graph-uri <graph_uris>: Named graph URI to scope mining queries to (repeatable). When omitted, graph_uris from sources.yaml are used. Pass ‘–graph-uri none’ to mine all graphs.

--endpoint <endpoint>: Local QLever SPARQL endpoint URL.

--name <name>: Dataset name (single-dataset mode).

--discover-first: Run VoID discovery before mining.

--void-uri-base <void_uri_base>: Base URI for generated VoID partition IRIs.

--test: Process only the 3 smallest downloadable sources.

mine

Mine schemas from remote SPARQL endpoints.

Standard mining workflow: iterate endpoints, extract schema patterns, write JSON-LD schemas, VoID turtle, and analytics reports.

Examples:

rdfsolve mine
rdfsolve mine --filter "drugbank"
rdfsolve mine --benchmark

Usage

rdfsolve mine [OPTIONS]

Options

--benchmark: Collect per-run benchmarks (timing, memory, CPU).

--filter <name_filter>: Regex to select sources by name.

--timeout <timeout>: HTTP timeout per SPARQL request (seconds).

--format <fmt>

Export format.

Options:: jsonld | void | all

--output-dir <output_dir>: Output directory for schemas/reports.

--sources <sources>: Path to sources YAML/JSON-LD/CSV.

--one-shot: Mine using a single unbounded SELECT per pattern type (no LIMIT/OFFSET, no fallback chain). Recommended for local QLever endpoints.

--author <NAME|ORCID>: Credit an author in provenance metadata. Format: ‘Full Name|0000-0000-0000-0000’. ORCID is optional. Repeat for multiple authors.

--untyped-as-classes: Treat untyped URI objects as owl:Class references.

--no-counts: Skip triple-count queries (faster).

--class-batch-size <class_batch_size>: Classes per VALUES query in two-phase mining.

--class-chunk-size <class_chunk_size>: Page size for Phase-1 class discovery (two-phase mode only). Default: no pagination.

--chunk-size <chunk_size>: SPARQL pagination page size.

ontology-index

Build and persist an OntologyIndex from OLS4 metadata.

Indexes ontology class hierarchies from the EBI Ontology Lookup Service (OLS4) and persists the result to disk and/or database.

Usage

rdfsolve ontology-index [OPTIONS]

Options

--ontologies <ontologies>: Explicit OLS4 ontology IDs to index (repeatable). Default: all.

--from-schemas <from_schemas_dir>: Directory with *_schema.jsonld files to restrict indexing.

--from-sources <from_sources_yaml>: Sources YAML whose URI prefixes restrict indexing.

--cache-dir <cache_dir>: Directory for the OLS4 HTTP-response diskcache.

--data-dir <data_dir>: Directory to write ontology_index.pkl.gz / ontology_graph.graphml.

--db <db>: Path to rdfsolve SQLite database for DB persistence.

--dry-run: Build the index but do not write any files or DB rows.

qlever-boot

Boot QLever SPARQL endpoint(s) via Singularity.

Generates a Qleverfile, downloads data, builds the index, and starts the SPARQL server for one or more sources from sources.yaml.

Usage

rdfsolve qlever-boot [OPTIONS]

Options

--source <sources>: Source name (repeatable). Must match ‘name’ in sources.yaml.

--filter <name_filter>: Regex filter applied to source names.

--sources-yaml <sources_yaml>

Path to sources.yaml.

Default:: 'data/sources.yaml'

--list-sources: List downloadable sources and exit.

--step <step>

Which pipeline step(s) to run.

Default:: 'all'
Options:: all | setup | get-data | index | start | stop | index-start | setup-data

--data-dir <data_dir>

Root data directory.

Default:: 'data'

--port <port>

Base SPARQL server port.

Default:: 7019

--runtime <runtime>

QLever runtime for the Qleverfile.

Default:: 'native'
Options:: native | docker

--singularity-image <singularity_image>

Default:: './data/qlever.sif'

--docker-ref <docker_ref>

Default:: 'docker://adfreiburg/qlever:latest'

--memory-for-queries <memory_for_queries>

Default:: '500G'

--timeout <qlever_timeout>

Default:: '9999999999s'

--parser-buffer-size <parser_buffer_size>

Default:: '8GB'

--parallel-parsing

--num-triples-per-batch <num_triples_per_batch>

Default:: 1000000

--qlever-image <qlever_image>

Default:: 'docker.io/adfreiburg/qlever:latest'

--num-threads <num_threads>

Default:: 8

--cache-size <cache_size>

Default:: '8G'

--server-memory <server_memory>

Default:: '40G'

--wait-timeout <wait_timeout>

Default:: 120

qleverfile

Generate Qleverfiles for local QLever mining.

Creates a Qleverfile for each source with download URLs.

Examples:

rdfsolve qleverfile --data-dir /data/rdf
rdfsolve qleverfile --data-dir /data/rdf --test
rdfsolve qleverfile --data-dir /data/rdf --server-memory 8G

Usage

rdfsolve qleverfile [OPTIONS]

Options

--benchmark: Collect per-run benchmarks (timing, memory, CPU).

--filter <name_filter>: Regex to select sources by name.

--timeout <timeout>: HTTP timeout per SPARQL request (seconds).

--format <fmt>

Export format.

Options:: jsonld | void | all

--output-dir <output_dir>: Output directory for schemas/reports.

--sources <sources>: Path to sources YAML/JSON-LD/CSV.

--data-dir <data_dir>: Required Root directory where RDF dumps live.

--base-port <base_port>: First port number.

--test: Generate only for 3 smallest downloadable sources.

--runtime <runtime>

QLever runtime.

Options:: docker | native

--server-memory <server_memory>

MEMORY_FOR_QUERIES written into every Qleverfile (-m flag for qlever-server). Lower this when many servers run concurrently on one node, e.g. ‘8G’.

Default:: '40G'

semra

SeMRA integration: import external mappings from semra sources.

Downloads mappings from community sources (biomappings, Gilda, etc.) and writes one JSON-LD file per (source, bioregistry-prefix) pair.

Typical workflow:

rdfsolve semra import --source biomappings
rdfsolve semra seed --sources biomappings gilda

Usage

rdfsolve semra [OPTIONS] COMMAND [ARGS]...

import

Import mappings from a single SeMRA source.

Writes {source}_{prefix}.jsonld for each unique subject prefix found in the downloaded mappings.

Usage

rdfsolve semra import [OPTIONS]

Options

-s, --source <source>: Required SeMRA source key (e.g. ‘biomappings’, ‘gilda’).

-p, --prefix <prefixes>: Keep only these bioregistry prefixes (repeatable). Default: keep all.

--output-dir <output_dir>

Directory to write JSON-LD files.

Default:: 'docker/mappings/semra'

--mapping-type <mapping_type>

Mapping type to store in @about.mapping_type. Use ‘instance’ for entity-level mappings (default) or ‘class’ for concept/class mappings.

Default:: 'instance'
Options:: instance | class

seed

Seed mapping files from multiple SeMRA sources.

Pass --sources all to import every registered SeMRA source. Use --exclude clo --exclude wikidata to skip problematic sources.

Usage

rdfsolve semra seed [OPTIONS]

Options

-s, --sources <source_list>: Required SeMRA source key (repeatable). Pass ‘all’ to import every registered source.

-x, --exclude <exclude_list>: SeMRA source key to exclude (repeatable). Useful with –sources all to skip sources that are known to fail (e.g. ‘clo’ requires Java, ‘wikidata’ hits 502 errors).

-p, --prefix <prefixes>: Keep only these bioregistry prefixes (repeatable).

--output-dir <output_dir>

Directory to write JSON-LD files.

Default:: 'docker/mappings/semra'

--mapping-type <mapping_type>

Mapping type to store in @about.mapping_type. Use ‘instance’ for entity-level mappings (default) or ‘class’ for concept/class mappings.

Default:: 'instance'
Options:: instance | class

sssom

SSSOM integration: import SSSOM mapping bundles.

Downloads SSSOM TSV bundles from the URLs listed in data/sssom_sources.yaml and writes one JSON-LD file per .sssom.tsv file extracted.

Typical workflow:

rdfsolve sssom import --name ols_mappings
rdfsolve sssom seed

Usage

rdfsolve sssom [OPTIONS] COMMAND [ARGS]...

import

Import one SSSOM source by name.

Usage

rdfsolve sssom import [OPTIONS]

Options

-n, --name <name>: Required Source name as defined in sssom_sources.yaml.

--url <url>: Override the URL for this source (default: read from YAML).

--sources-yaml <sources_yaml>

Path to the SSSOM sources YAML file.

Default:: 'data/sssom_sources.yaml'

--output-dir <output_dir>

Directory to write JSON-LD files.

Default:: 'docker/mappings/sssom'

--mapping-type <mapping_type>

Mapping type to store in @about.mapping_type. Use ‘instance’ for entity-level mappings (default) or ‘class’ for concept/class mappings.

Default:: 'instance'
Options:: instance | class

seed

Seed SSSOM mapping files for all (or selected) sources.

Entries whose type is property_mappings are routed to --property-mappings-dir (default: <output-dir>/../property_mappings/). All other entries are written to --output-dir.

Usage

rdfsolve sssom seed [OPTIONS]

Options

--sources-yaml <sources_yaml>

Path to the SSSOM sources YAML file.

Default:: 'data/sssom_sources.yaml'

--output-dir <output_dir>

Directory to write JSON-LD files.

Default:: 'docker/mappings/sssom'

--property-mappings-dir <property_mappings_dir>: Output directory for entries with type: property_mappings. Defaults to <output-dir>/../property_mappings/.

-n, --name <names>: Process only sources with these names (repeatable). Default: process all.

--mapping-type <mapping_type>

Mapping type to store in @about.mapping_type. Use ‘instance’ for entity-level mappings (default) or ‘class’ for concept/class mappings.

Default:: 'instance'
Options:: instance | class