@thomasfosterau/effect-rdf 0.0.0-stage → 0.1.0

package/dist/RdfJs-D6-49XB5.mjs

@@ -0,0 +1,86 @@
+import { t as __exportAll } from "./rolldown-runtime-D8jQpDG7.mjs";
+import { O as defaultGraph, S as Variable, Y as literal, c as NamedNode, d as Quad, t as BlankNode, y as Triple } from "./Term-CFLG1qu4.mjs";
+import * as Match from "effect/Match";
+// src/RdfJs.ts
+/**
+* Conversions to and from the RDF/JS data model
+* (https://rdf.js.org/data-model-spec/), for interoperability with the wider
+* JavaScript RDF ecosystem. No RDF/JS packages are required: the interfaces
+* below are structural.
+*
+* @since 0.1.0
+*/
+var RdfJs_exports = /* @__PURE__ */ __exportAll({
+	fromQuad: () => fromQuad,
+	fromTerm: () => fromTerm,
+	toQuad: () => toQuad,
+	toTerm: () => toTerm
+});
+const fromTermMatch = Match.type().pipe(Match.withReturnType(), Match.when({ termType: "NamedNode" }, (term) => new NamedNode(term.value)), Match.when({ termType: "BlankNode" }, (term) => new BlankNode(term.value)), Match.when({ termType: "Literal" }, (term) => term.language !== "" ? literal(term.value, {
+	language: term.language,
+	direction: term.direction === "ltr" || term.direction === "rtl" ? term.direction : void 0
+}) : literal(term.value, new NamedNode(term.datatype.value))), Match.when({ termType: "Variable" }, (term) => new Variable(term.value)), Match.when({ termType: "DefaultGraph" }, () => defaultGraph), Match.when({ termType: "Quad" }, (term) => new Triple(fromTerm(term.subject), fromTerm(term.predicate), fromTerm(term.object))), Match.exhaustive);
+/**
+* Converts an RDF/JS term. Quads appearing as terms become triple terms.
+*
+* @since 0.1.0
+* @category conversions
+*/
+const fromTerm = (term) => fromTermMatch(term);
+/**
+* Converts an RDF/JS quad to a `Quad`.
+*
+* @since 0.1.0
+* @category conversions
+*/
+const fromQuad = (quad) => new Quad(fromTerm(quad.subject), fromTerm(quad.predicate), fromTerm(quad.object), fromTerm(quad.graph));
+const toTermMatch = Match.type().pipe(Match.withReturnType(), Match.tag("NamedNode", "BlankNode", "Variable", (term) => ({
+	termType: term._tag,
+	value: term.value
+})), Match.tag("DefaultGraph", () => ({
+	termType: "DefaultGraph",
+	value: ""
+})), Match.tag("Literal", (term) => ({
+	termType: "Literal",
+	value: term.value,
+	language: term.language,
+	direction: term.direction ?? "",
+	datatype: {
+		termType: "NamedNode",
+		value: term.datatype.value
+	}
+})), Match.tag("Triple", (term) => ({
+	termType: "Quad",
+	value: "",
+	subject: toTerm(term.subject),
+	predicate: toTerm(term.predicate),
+	object: toTerm(term.object),
+	graph: {
+		termType: "DefaultGraph",
+		value: ""
+	}
+})), Match.exhaustive);
+/**
+* Converts a term to a plain RDF/JS term object.
+*
+* @since 0.1.0
+* @category conversions
+*/
+const toTerm = (term) => toTermMatch(term);
+/**
+* Converts a quad to a plain RDF/JS quad object.
+*
+* @since 0.1.0
+* @category conversions
+*/
+const toQuad = (quad) => ({
+	termType: "Quad",
+	value: "",
+	subject: toTerm(quad.subject),
+	predicate: toTerm(quad.predicate),
+	object: toTerm(quad.object),
+	graph: toTerm(quad.graph)
+});
+export { toTerm as a, toQuad as i, fromQuad as n, fromTerm as r, RdfJs_exports as t };
+
+//# sourceMappingURL=RdfJs-D6-49XB5.mjs.map

package/dist/RdfJs-D6-49XB5.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"RdfJs-D6-49XB5.mjs","names":["Term.NamedNode","Term.BlankNode","Term.literal","Term.Variable","Term.defaultGraph","Term.Triple","Term.Quad"],"sources":["../src/RdfJs.ts"],"sourcesContent":["/**\n * Conversions to and from the RDF/JS data model\n * (https://rdf.js.org/data-model-spec/), for interoperability with the wider\n * JavaScript RDF ecosystem. No RDF/JS packages are required: the interfaces\n * below are structural.\n *\n * @since 0.1.0\n */\nimport * as Match from 'effect/Match';\nimport * as Term from './Term.ts';\n\n/**\n * A structural RDF/JS term.\n *\n * @since 0.1.0\n * @category models\n */\nexport type RdfJsTerm =\n  | { readonly termType: 'NamedNode'; readonly value: string }\n  | { readonly termType: 'BlankNode'; readonly value: string }\n  | {\n      readonly termType: 'Literal';\n      readonly value: string;\n      readonly language: string;\n      readonly direction?: 'ltr' | 'rtl' | '' | null | undefined;\n      readonly datatype: { readonly termType: 'NamedNode'; readonly value: string };\n    }\n  | { readonly termType: 'Variable'; readonly value: string }\n  | { readonly termType: 'DefaultGraph'; readonly value: '' }\n  | RdfJsQuad;\n\n/**\n * A structural RDF/JS quad (also used for quoted triples).\n *\n * @since 0.1.0\n * @category models\n */\nexport interface RdfJsQuad {\n  readonly termType: 'Quad';\n  readonly value: '';\n  readonly subject: RdfJsTerm;\n  readonly predicate: RdfJsTerm;\n  readonly object: RdfJsTerm;\n  readonly graph: RdfJsTerm;\n}\n\n// Built once: `fromTerm` runs for every term of every quad converted.\nconst fromTermMatch: (term: RdfJsTerm) => Term.Term = Match.type<RdfJsTerm>().pipe(\n  Match.withReturnType<Term.Term>(),\n  Match.when({ termType: 'NamedNode' }, (term) => new Term.NamedNode(term.value)),\n  Match.when({ termType: 'BlankNode' }, (term) => new Term.BlankNode(term.value)),\n  Match.when({ termType: 'Literal' }, (term) =>\n    term.language !== ''\n      ? Term.literal(term.value, {\n          language: term.language,\n          direction:\n            term.direction === 'ltr' || term.direction === 'rtl' ? term.direction : undefined,\n        })\n      : Term.literal(term.value, new Term.NamedNode(term.datatype.value)),\n  ),\n  Match.when({ termType: 'Variable' }, (term) => new Term.Variable(term.value)),\n  Match.when({ termType: 'DefaultGraph' }, () => Term.defaultGraph),\n  // SAFETY: an RDF/JS quad term's components are a subject, a predicate and an object.\n  Match.when(\n    { termType: 'Quad' },\n    (term) =>\n      new Term.Triple(\n        fromTerm(term.subject) as Term.Subject,\n        fromTerm(term.predicate) as Term.Predicate,\n        fromTerm(term.object) as Term.Object,\n      ),\n  ),\n  Match.exhaustive,\n);\n\n/**\n * Converts an RDF/JS term. Quads appearing as terms become triple terms.\n *\n * @since 0.1.0\n * @category conversions\n */\nexport const fromTerm = (term: RdfJsTerm): Term.Term => fromTermMatch(term);\n\n/**\n * Converts an RDF/JS quad to a `Quad`.\n *\n * @since 0.1.0\n * @category conversions\n */\n// SAFETY: an RDF/JS quad's components are a subject, a predicate, an object and a graph.\nexport const fromQuad = (quad: RdfJsQuad): Term.Quad =>\n  new Term.Quad(\n    fromTerm(quad.subject) as Term.Subject,\n    fromTerm(quad.predicate) as Term.Predicate,\n    fromTerm(quad.object) as Term.Object,\n    fromTerm(quad.graph) as Term.Graph,\n  );\n\n// Built once: `toTerm` runs for every term of every quad converted.\nconst toTermMatch: (term: Term.Term) => RdfJsTerm = Match.type<Term.Term>().pipe(\n  Match.withReturnType<RdfJsTerm>(),\n  Match.tag('NamedNode', 'BlankNode', 'Variable', (term) => ({\n    termType: term._tag,\n    value: term.value,\n  })),\n  Match.tag('DefaultGraph', () => ({ termType: 'DefaultGraph', value: '' })),\n  Match.tag('Literal', (term) => ({\n    termType: 'Literal',\n    value: term.value,\n    language: term.language,\n    direction: term.direction ?? '',\n    datatype: { termType: 'NamedNode', value: term.datatype.value },\n  })),\n  Match.tag('Triple', (term) => ({\n    termType: 'Quad',\n    value: '',\n    subject: toTerm(term.subject),\n    predicate: toTerm(term.predicate),\n    object: toTerm(term.object),\n    graph: { termType: 'DefaultGraph', value: '' },\n  })),\n  Match.exhaustive,\n);\n\n/**\n * Converts a term to a plain RDF/JS term object.\n *\n * @since 0.1.0\n * @category conversions\n */\nexport const toTerm = (term: Term.Term): RdfJsTerm => toTermMatch(term);\n\n/**\n * Converts a quad to a plain RDF/JS quad object.\n *\n * @since 0.1.0\n * @category conversions\n */\nexport const toQuad = (quad: Term.Quad): RdfJsQuad => ({\n  termType: 'Quad',\n  value: '',\n  subject: toTerm(quad.subject),\n  predicate: toTerm(quad.predicate),\n  object: toTerm(quad.object),\n  graph: toTerm(quad.graph),\n});\n"],"mappings":";;;;;;;;;;;;;;;;;;AA+CA,MAAM,gBAAgD,MAAM,KAAgB,CAAC,CAAC,KAC5E,MAAM,eAA0B,GAChC,MAAM,KAAK,EAAE,UAAU,YAAY,IAAI,SAAS,IAAIA,UAAe,KAAK,KAAK,CAAC,GAC9E,MAAM,KAAK,EAAE,UAAU,YAAY,IAAI,SAAS,IAAIC,UAAe,KAAK,KAAK,CAAC,GAC9E,MAAM,KAAK,EAAE,UAAU,UAAU,IAAI,SACnC,KAAK,aAAa,KACdC,QAAa,KAAK,OAAO;CACvB,UAAU,KAAK;CACf,WACE,KAAK,cAAc,SAAS,KAAK,cAAc,QAAQ,KAAK,YAAY,KAAA;AAC5E,CAAC,IACDA,QAAa,KAAK,OAAO,IAAIF,UAAe,KAAK,SAAS,KAAK,CAAC,CACtE,GACA,MAAM,KAAK,EAAE,UAAU,WAAW,IAAI,SAAS,IAAIG,SAAc,KAAK,KAAK,CAAC,GAC5E,MAAM,KAAK,EAAE,UAAU,eAAe,SAASC,YAAiB,GAEhE,MAAM,KACJ,EAAE,UAAU,OAAO,IAClB,SACC,IAAIC,OACF,SAAS,KAAK,OAAO,GACrB,SAAS,KAAK,SAAS,GACvB,SAAS,KAAK,MAAM,CACtB,CACJ,GACA,MAAM,UACR;;;;;;;AAQA,MAAa,YAAY,SAA+B,cAAc,IAAI;;;;;;;AAS1E,MAAa,YAAY,SACvB,IAAIC,KACF,SAAS,KAAK,OAAO,GACrB,SAAS,KAAK,SAAS,GACvB,SAAS,KAAK,MAAM,GACpB,SAAS,KAAK,KAAK,CACrB;AAGF,MAAM,cAA8C,MAAM,KAAgB,CAAC,CAAC,KAC1E,MAAM,eAA0B,GAChC,MAAM,IAAI,aAAa,aAAa,aAAa,UAAU;CACzD,UAAU,KAAK;CACf,OAAO,KAAK;AACd,EAAE,GACF,MAAM,IAAI,uBAAuB;CAAE,UAAU;CAAgB,OAAO;AAAG,EAAE,GACzE,MAAM,IAAI,YAAY,UAAU;CAC9B,UAAU;CACV,OAAO,KAAK;CACZ,UAAU,KAAK;CACf,WAAW,KAAK,aAAa;CAC7B,UAAU;EAAE,UAAU;EAAa,OAAO,KAAK,SAAS;CAAM;AAChE,EAAE,GACF,MAAM,IAAI,WAAW,UAAU;CAC7B,UAAU;CACV,OAAO;CACP,SAAS,OAAO,KAAK,OAAO;CAC5B,WAAW,OAAO,KAAK,SAAS;CAChC,QAAQ,OAAO,KAAK,MAAM;CAC1B,OAAO;EAAE,UAAU;EAAgB,OAAO;CAAG;AAC/C,EAAE,GACF,MAAM,UACR;;;;;;;AAQA,MAAa,UAAU,SAA+B,YAAY,IAAI;;;;;;;AAQtE,MAAa,UAAU,UAAgC;CACrD,UAAU;CACV,OAAO;CACP,SAAS,OAAO,KAAK,OAAO;CAC5B,WAAW,OAAO,KAAK,SAAS;CAChC,QAAQ,OAAO,KAAK,MAAM;CAC1B,OAAO,OAAO,KAAK,KAAK;AAC1B"}

package/dist/RdfJs-DXFqdWrd.d.mts

@@ -0,0 +1,76 @@
+import { T as Term, _ as Quad } from "./Term-B_4ezyXq.mjs";
+declare namespace RdfJs_d_exports {
+  export { RdfJsQuad, RdfJsTerm, fromQuad, fromTerm, toQuad, toTerm };
+}
+/**
+ * A structural RDF/JS term.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+type RdfJsTerm = {
+  readonly termType: 'NamedNode';
+  readonly value: string;
+} | {
+  readonly termType: 'BlankNode';
+  readonly value: string;
+} | {
+  readonly termType: 'Literal';
+  readonly value: string;
+  readonly language: string;
+  readonly direction?: 'ltr' | 'rtl' | '' | null | undefined;
+  readonly datatype: {
+    readonly termType: 'NamedNode';
+    readonly value: string;
+  };
+} | {
+  readonly termType: 'Variable';
+  readonly value: string;
+} | {
+  readonly termType: 'DefaultGraph';
+  readonly value: '';
+} | RdfJsQuad;
+/**
+ * A structural RDF/JS quad (also used for quoted triples).
+ *
+ * @since 0.1.0
+ * @category models
+ */
+interface RdfJsQuad {
+  readonly termType: 'Quad';
+  readonly value: '';
+  readonly subject: RdfJsTerm;
+  readonly predicate: RdfJsTerm;
+  readonly object: RdfJsTerm;
+  readonly graph: RdfJsTerm;
+}
+/**
+ * Converts an RDF/JS term. Quads appearing as terms become triple terms.
+ *
+ * @since 0.1.0
+ * @category conversions
+ */
+declare const fromTerm: (term: RdfJsTerm) => Term;
+/**
+ * Converts an RDF/JS quad to a `Quad`.
+ *
+ * @since 0.1.0
+ * @category conversions
+ */
+declare const fromQuad: (quad: RdfJsQuad) => Quad;
+/**
+ * Converts a term to a plain RDF/JS term object.
+ *
+ * @since 0.1.0
+ * @category conversions
+ */
+declare const toTerm: (term: Term) => RdfJsTerm;
+/**
+ * Converts a quad to a plain RDF/JS quad object.
+ *
+ * @since 0.1.0
+ * @category conversions
+ */
+declare const toQuad: (quad: Quad) => RdfJsQuad;
+export { fromTerm as a, fromQuad as i, RdfJsTerm as n, toQuad as o, RdfJs_d_exports as r, toTerm as s, RdfJsQuad as t };
+//# sourceMappingURL=RdfJs-DXFqdWrd.d.mts.map

package/dist/RdfJs.d.mts

@@ -0,0 +1,2 @@
+import { a as fromTerm, i as fromQuad, n as RdfJsTerm, o as toQuad, s as toTerm, t as RdfJsQuad } from "./RdfJs-DXFqdWrd.mjs";
+export { RdfJsQuad, RdfJsTerm, fromQuad, fromTerm, toQuad, toTerm };

package/dist/RdfJs.mjs

@@ -0,0 +1 @@
+export { n as fromQuad, r as fromTerm, i as toQuad, a as toTerm } from "./RdfJs-D6-49XB5.mjs";

package/dist/RdfJson-5aKPDlPS.d.mts

@@ -0,0 +1,297 @@
+import { _ as Quad, i as Direction, o as Graph } from "./Term-B_4ezyXq.mjs";
+import { n as Dataset } from "./Dataset-DS3ESOcO.mjs";
+import { c as Parser, i as Format, l as RdfParseError, m as Serializer, o as ParseOptions$1, p as SerializeOptions$1, r as Codec, s as ParseResult, u as RdfSerializeError } from "./Serialization-Df8iVauT.mjs";
+import * as Schema from "effect/Schema";
+import * as Effect from "effect/Effect";
+declare namespace RdfJson_d_exports {
+  export { BlankNodeValue, DatasetFromRdfJson, DatasetFromString, Document, FromQuadsOptions, LiteralValue, ObjectValue, ParseOptions, RdfJsonFromString, SerializeOptions, StrictDocument, StrictObjectValue, ToDatasetOptions, TripleTermValue, UriValue, codec, format, fromQuads, makeDatasetSchema, parse, parser, serialize, serializer, toDataset };
+}
+/**
+ * The RDF/JSON format description.
+ *
+ * @since 0.1.0
+ * @category formats
+ */
+declare const format: Format;
+/**
+ * An IRI value: `{ "type": "uri", "value": "http://…" }`.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+type UriValue = {
+  readonly type: 'uri';
+  readonly value: string;
+};
+/**
+ * A blank node value: `{ "type": "bnode", "value": "_:label" }`.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+type BlankNodeValue = {
+  readonly type: 'bnode';
+  readonly value: string;
+};
+/**
+ * A literal value. `lang` and `datatype` are mutually exclusive;
+ * `direction` is an RDF 1.2 extension that requires `lang`.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+type LiteralValue = {
+  readonly type: 'literal';
+  readonly value: string;
+  readonly lang?: string;
+  readonly datatype?: string;
+  readonly direction?: Direction;
+};
+/**
+ * An RDF 1.2 triple term value (extension).
+ *
+ * @since 0.1.0
+ * @category models
+ */
+type TripleTermValue = {
+  readonly type: 'triple';
+  readonly value: {
+    readonly subject: UriValue | BlankNodeValue;
+    readonly predicate: UriValue;
+    readonly object: ObjectValue;
+  };
+};
+/**
+ * Any value in the object position.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+type ObjectValue = UriValue | BlankNodeValue | LiteralValue | TripleTermValue;
+/**
+ * An RDF/JSON document: subject → predicate → array of object values.
+ * Subjects are IRIs or blank node labels (`"_:label"`).
+ *
+ * @since 0.1.0
+ * @category models
+ */
+interface Document {
+  readonly [subject: string]: {
+    readonly [predicate: string]: ReadonlyArray<ObjectValue>;
+  };
+}
+/**
+ * @since 0.1.0
+ * @category schemas
+ */
+declare const UriValue: Schema.Codec<UriValue>;
+/**
+ * @since 0.1.0
+ * @category schemas
+ */
+declare const BlankNodeValue: Schema.Codec<BlankNodeValue>;
+/**
+ * @since 0.1.0
+ * @category schemas
+ */
+declare const LiteralValue: Schema.Codec<LiteralValue>;
+/**
+ * An RDF 1.2 triple term (extension).
+ *
+ * @since 0.1.0
+ * @category schemas
+ */
+declare const TripleTermValue: Schema.Codec<TripleTermValue>;
+/**
+ * Any object value, including the RDF 1.2 extensions.
+ *
+ * @since 0.1.0
+ * @category schemas
+ */
+declare const ObjectValue: Schema.Codec<ObjectValue>;
+/**
+ * The type of an object value in strict RDF/JSON (the `StrictObjectValue`
+ * schema's decoded type).
+ *
+ * @since 0.1.0
+ * @category models
+ */
+type StrictObjectValue = typeof StrictObjectValue.Type;
+/**
+ * An object value in strict RDF/JSON: no triple terms and no base
+ * direction.
+ *
+ * @since 0.1.0
+ * @category schemas
+ */
+declare const StrictObjectValue: Schema.Codec<UriValue | BlankNodeValue | LiteralValue>;
+/**
+ * An RDF/JSON document, accepting the RDF 1.2 extensions.
+ *
+ * @since 0.1.0
+ * @category schemas
+ */
+declare const Document: Schema.Codec<Document>;
+/**
+ * A strict RDF/JSON document, rejecting the RDF 1.2 extensions.
+ *
+ * @since 0.1.0
+ * @category schemas
+ */
+declare const StrictDocument: Schema.Codec<Document>;
+/**
+ * The decoded type of `RdfJsonFromString`: a validated `Document`.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+type RdfJsonFromString = typeof RdfJsonFromString.Type;
+/**
+ * Decodes RDF/JSON text into a validated `Document` (and encodes documents
+ * as JSON text).
+ *
+ * @since 0.1.0
+ * @category schemas
+ */
+declare const RdfJsonFromString: Schema.Codec<Document, string>;
+/**
+ * Options for converting RDF/JSON documents to datasets.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+interface ToDatasetOptions {
+  /** The graph to place triples in. Defaults to the default graph. */
+  readonly graph?: Graph | undefined;
+  /**
+   * Prefix for blank node labels. Defaults to a fresh prefix per document,
+   * so that blank nodes from different documents never clash.
+   */
+  readonly blankNodePrefix?: string | undefined;
+}
+/**
+ * Converts a (validated) RDF/JSON document to a dataset.
+ *
+ * @since 0.1.0
+ * @category conversions
+ */
+declare const toDataset: (document: Document, options?: ToDatasetOptions) => Dataset;
+/**
+ * Options for converting quads to RDF/JSON.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+interface FromQuadsOptions {
+  /**
+   * Whether to use the RDF 1.2 extensions (base direction and triple terms).
+   * When `false` (the default), data that needs them is rejected with an
+   * `RdfSerializeError`.
+   */
+  readonly extensions?: boolean | undefined;
+  /**
+   * Whether to merge quads from named graphs into the single RDF/JSON graph.
+   * When `false` (the default), quads in named graphs are rejected.
+   */
+  readonly mergeGraphs?: boolean | undefined;
+}
+/**
+ * Converts quads to an RDF/JSON document.
+ *
+ * @since 0.1.0
+ * @category conversions
+ */
+declare const fromQuads: (quads: Iterable<Quad>, options?: FromQuadsOptions) => Effect.Effect<Document, RdfSerializeError>;
+/**
+ * Builds a schema transforming RDF/JSON documents into datasets and back,
+ * with the given conversion options.
+ *
+ * @since 0.1.0
+ * @category schemas
+ */
+declare const makeDatasetSchema: (options?: ToDatasetOptions & FromQuadsOptions & {
+  readonly strict?: boolean | undefined;
+}) => Schema.Codec<Dataset, Document>;
+/**
+ * A schema transforming RDF/JSON documents into datasets and back. Decoding
+ * accepts the RDF 1.2 extensions; encoding writes strict RDF/JSON and fails
+ * for data that needs the extensions or uses named graphs.
+ *
+ * @since 0.1.0
+ * @category schemas
+ */
+declare const DatasetFromRdfJson: Schema.Codec<Dataset, Document>;
+/**
+ * The decoded type of `DatasetFromString`: a `Dataset`.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+type DatasetFromString = typeof DatasetFromString.Type;
+/**
+ * A schema transforming RDF/JSON text into datasets and back.
+ *
+ * @since 0.1.0
+ * @category schemas
+ */
+declare const DatasetFromString: Schema.Codec<Dataset, string>;
+/**
+ * Options for parsing RDF/JSON.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+interface ParseOptions extends ParseOptions$1 {
+  /** Reject the RDF 1.2 extensions. Defaults to `false`. */
+  readonly strict?: boolean | undefined;
+}
+/**
+ * Parses RDF/JSON text into a dataset. The document shape is validated with
+ * the `Document` schema (or `StrictDocument` when `strict` is set), and
+ * validation failures are reported as `RdfParseError`s.
+ *
+ * @since 0.1.0
+ * @category parsing
+ */
+declare const parse: (input: string, options?: ParseOptions) => Effect.Effect<ParseResult, RdfParseError>;
+/**
+ * Options for serialising RDF/JSON.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+interface SerializeOptions extends SerializeOptions$1, FromQuadsOptions {
+  /** Indentation passed to `JSON.stringify`. Defaults to 2 spaces. */
+  readonly space?: number | string | undefined;
+}
+/**
+ * Serialises quads as RDF/JSON text.
+ *
+ * @since 0.1.0
+ * @category serializing
+ */
+declare const serialize: (quads: Iterable<Quad>, options?: SerializeOptions) => Effect.Effect<string, RdfSerializeError>;
+/**
+ * The RDF/JSON parser.
+ *
+ * @since 0.1.0
+ * @category parsing
+ */
+declare const parser: Parser<ParseOptions>;
+/**
+ * The RDF/JSON serializer.
+ *
+ * @since 0.1.0
+ * @category serializing
+ */
+declare const serializer: Serializer<SerializeOptions>;
+/**
+ * The RDF/JSON codec. Its `schema` is `DatasetFromString`, so decoding
+ * errors carry the precise schema issue.
+ *
+ * @since 0.1.0
+ * @category codecs
+ */
+declare const codec: Codec<ParseOptions, SerializeOptions>;
+export { serialize as C, parser as S, toDataset as T, codec as _, FromQuadsOptions as a, makeDatasetSchema as b, ParseOptions as c, SerializeOptions as d, StrictDocument as f, UriValue as g, TripleTermValue as h, Document as i, RdfJsonFromString as l, ToDatasetOptions as m, DatasetFromRdfJson as n, LiteralValue as o, StrictObjectValue as p, DatasetFromString as r, ObjectValue as s, BlankNodeValue as t, RdfJson_d_exports as u, format as v, serializer as w, parse as x, fromQuads as y };
+//# sourceMappingURL=RdfJson-5aKPDlPS.d.mts.map