@shaclmate/compiler 2.0.12 → 2.0.14

package/enums/index.js

@@ -0,0 +1,5 @@
+export * from "./MintingStrategy.js";
+export * from "./PropertyVisibility.js";
+export * from "./TsFeature.js";
+export * from "./TsObjectDeclarationType.js";
+//# sourceMappingURL=index.js.map

package/generators/Generator.d.ts

@@ -0,0 +1,5 @@
+import type { Ast } from "../ast/Ast.js";
+export interface Generator {
+    generate(ast: Ast): string;
+}
+//# sourceMappingURL=Generator.d.ts.map

package/generators/Generator.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=Generator.js.map

package/generators/index.d.ts

@@ -1,3 +1,3 @@
-export * as json from "./json";
-export * as ts from "./ts";
+export * as json from "./json/index.js";
+export * as ts from "./ts/index.js";
 //# sourceMappingURL=index.d.ts.map

package/generators/index.js

@@ -1,3 +1,3 @@
-export * as json from "./json";
-export * as ts from "./ts";
+export * as json from "./json/index.js";
+export * as ts from "./ts/index.js";
 //# sourceMappingURL=index.js.map

package/generators/json/AstJsonGenerator.d.ts

@@ -1,7 +1,6 @@
-import type * as ast from "../../ast";
-export declare class AstJsonGenerator {
-    private readonly ast;
-    constructor(ast: ast.Ast);
-    generate(): string;
+import type * as ast from "../../ast/index.js";
+import type { Generator } from "../Generator.js";
+export declare class AstJsonGenerator implements Generator {
+    generate(ast: ast.Ast): string;
 }
 //# sourceMappingURL=AstJsonGenerator.d.ts.map

package/generators/json/AstJsonGenerator.js

@@ -1,4 +1,3 @@
-import * as shaclAst from "shacl-ast";
 function nameToJson(name) {
     return {
         curie: name.curie.extract(),
@@ -7,16 +6,6 @@ function nameToJson(name) {
         shaclmateName: name.shaclmateName.extract(),
     };
 }
-function nodeKindToJson(nodeKind) {
-    switch (nodeKind) {
-        case shaclAst.NodeKind.BLANK_NODE:
-            return "BlankNode";
-        case shaclAst.NodeKind.IRI:
-            return "NamedNode";
-        case shaclAst.NodeKind.LITERAL:
-            return "Literal";
-    }
-}
 function termToJson(term) {
     switch (term.termType) {
         case "BlankNode":
@@ -38,9 +27,9 @@ function typeToJson(type) {
     switch (type.kind) {
         case "IdentifierType":
             return {
-                hasValue: type.hasValue.map(termToJson).extract(),
+                hasValue: type.hasValues.map(termToJson),
                 kind: type.kind,
-                nodeKinds: [...type.nodeKinds].map(nodeKindToJson),
+                nodeKinds: [...type.nodeKinds],
             };
         case "IntersectionType":
         case "UnionType":
@@ -48,10 +37,17 @@ function typeToJson(type) {
                 kind: type.kind,
                 types: type.memberTypes.map((type) => typeToJson(type)),
             };
+        case "ListType": {
+            return {
+                itemType: typeToJson(type.itemType),
+                kind: type.kind,
+                mutable: type.mutable.extract(),
+            };
+        }
         case "LiteralType": {
             return {
                 datatype: type.datatype.extract(),
-                hasValue: type.hasValue.map(termToJson).extract(),
+                hasValue: type.hasValues.map(termToJson),
                 kind: type.kind,
                 maxExclusive: type.maxExclusive.map(termToJson).extract(),
                 maxInclusive: type.maxInclusive.map(termToJson).extract(),
@@ -59,40 +55,53 @@ function typeToJson(type) {
                 minInclusive: type.minInclusive.map(termToJson).extract(),
             };
         }
+        case "ObjectIntersectionType":
+        case "ObjectUnionType":
+            return {
+                kind: type.kind,
+                name: nameToJson(type.name),
+                types: type.memberTypes.map((type) => typeToJson(type)),
+            };
         case "ObjectType":
             return {
+                fromRdfType: type.fromRdfType.map(termToJson).extract(),
                 kind: type.kind,
-                listItemType: type.listItemType.map(typeToJson).extract(),
                 name: nameToJson(type.name),
                 parentObjectTypes: type.parentObjectTypes.length > 0
                     ? type.parentObjectTypes.map((type) => nameToJson(type.name))
                     : undefined,
-                nodeKinds: [...type.nodeKinds].map(nodeKindToJson),
-                rdfType: type.rdfType.map(termToJson).extract(),
+                nodeKinds: [...type.nodeKinds],
+                toRdfTypes: type.toRdfTypes.length > 0
+                    ? type.toRdfTypes.map(termToJson)
+                    : undefined,
             };
         case "OptionType":
             return {
                 itemType: typeToJson(type.itemType),
                 kind: type.kind,
             };
+        case "PlaceholderType":
+            throw new Error(type.kind);
         case "SetType":
             return {
                 itemType: typeToJson(type.itemType),
                 kind: type.kind,
             };
+        case "TermType":
+            return {
+                kind: type.kind,
+            };
     }
 }
 export class AstJsonGenerator {
-    constructor(ast) {
-        this.ast = ast;
-    }
-    generate() {
+    generate(ast) {
         return JSON.stringify({
-            objectTypes: this.ast.objectTypes.map((objectType) => ({
+            objectTypes: ast.objectTypes.map((objectType) => ({
                 kind: objectType.kind,
                 name: nameToJson(objectType.name),
                 properties: objectType.properties.map((property) => ({
                     name: nameToJson(property.name),
+                    mutable: property.mutable.extract(),
                     path: property.path.iri.value,
                     type: typeToJson(property.type),
                 })),

package/generators/ts/BooleanType.d.ts

@@ -1,7 +1,11 @@
 import { PrimitiveType } from "./PrimitiveType.js";
-export declare class BooleanType extends PrimitiveType {
+import type { Type } from "./Type.js";
+export declare class BooleanType extends PrimitiveType<boolean> {
+    readonly kind = "BooleanType";
+    get conversions(): readonly Type.Conversion[];
     get name(): string;
-    fromRdfResourceValueExpression({ variables, }: Parameters<PrimitiveType["fromRdfResourceValueExpression"]>[0]): string;
-    hashStatements({ variables, }: Parameters<PrimitiveType["hashStatements"]>[0]): readonly string[];
+    jsonZodSchema({ variables, }: Parameters<Type["jsonZodSchema"]>[0]): ReturnType<Type["jsonZodSchema"]>;
+    propertyFromRdfResourceValueExpression({ variables, }: Parameters<PrimitiveType<boolean>["propertyFromRdfResourceValueExpression"]>[0]): string;
+    toRdfExpression({ variables, }: Parameters<PrimitiveType<string>["toRdfExpression"]>[0]): string;
 }
 //# sourceMappingURL=BooleanType.d.ts.map

package/generators/ts/BooleanType.js

@@ -1,13 +1,67 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { Memoize } from "typescript-memoize";
 import { PrimitiveType } from "./PrimitiveType.js";
+import { objectInitializer } from "./objectInitializer.js";
 export class BooleanType extends PrimitiveType {
+    constructor() {
+        super(...arguments);
+        this.kind = "BooleanType";
+    }
+    get conversions() {
+        const conversions = [
+            {
+                conversionExpression: (value) => value,
+                sourceTypeCheckExpression: (value) => `typeof ${value} === "boolean"`,
+                sourceTypeName: this.name,
+            },
+        ];
+        this.primitiveDefaultValue.ifJust((defaultValue) => {
+            conversions.push({
+                conversionExpression: () => defaultValue.toString(),
+                sourceTypeCheckExpression: (value) => `typeof ${value} === "undefined"`,
+                sourceTypeName: "undefined",
+            });
+        });
+        return conversions;
+    }
     get name() {
+        if (this.primitiveIn.length > 0) {
+            return this.primitiveIn.map((value) => value.toString()).join(" | ");
+        }
         return "boolean";
     }
-    fromRdfResourceValueExpression({ variables, }) {
-        return `${variables.resourceValue}.toBoolean()`;
+    jsonZodSchema({ variables, }) {
+        if (this.primitiveIn.length === 1) {
+            return `${variables.zod}.literal(${this.primitiveIn[0]})`;
+        }
+        return `${variables.zod}.boolean()`;
+    }
+    propertyFromRdfResourceValueExpression({ variables, }) {
+        let expression = `${variables.resourceValue}.toBoolean()`;
+        if (this.primitiveIn.length === 1) {
+            expression = `${expression}.chain(value => value === ${this.primitiveIn[0]} ? purify.Either.of(value) : purify.Left(new rdfjsResource.Resource.MistypedValueError(${objectInitializer({ actualValue: "rdfLiteral.toRdf(value)", expectedValueType: JSON.stringify(this.name), focusResource: variables.resource, predicate: variables.predicate })})))`;
+        }
+        return expression;
     }
-    hashStatements({ variables, }) {
-        return [`${variables.hasher}.update(${variables.value}.toString());`];
+    toRdfExpression({ variables, }) {
+        return this.primitiveDefaultValue
+            .map((defaultValue) => {
+            if (defaultValue) {
+                // If the default is true, only serialize the value if it's false
+                return `!${variables.value} ? false : undefined`;
+            }
+            // If the default is false, only serialize the value if it's true
+            return `${variables.value} ? true : undefined`;
+        })
+            .orDefault(variables.value);
     }
 }
+__decorate([
+    Memoize()
+], BooleanType.prototype, "name", null);
 //# sourceMappingURL=BooleanType.js.map

package/generators/ts/DateTimeType.d.ts

@@ -0,0 +1,17 @@
+import { PrimitiveType } from "./PrimitiveType.js";
+import type { Type } from "./Type.js";
+export declare class DateTimeType extends PrimitiveType<Date> {
+    readonly equalsFunction = "(left, right) => purifyHelpers.Equatable.EqualsResult.fromBooleanEqualsResult(left, right, left.getTime() === right.getTime())";
+    readonly kind = "DateTimeType";
+    readonly mutable = true;
+    get conversions(): readonly Type.Conversion[];
+    get jsonName(): string;
+    get name(): string;
+    fromJsonExpression({ variables, }: Parameters<Type["fromJsonExpression"]>[0]): string;
+    hashStatements({ variables, }: Parameters<Type["hashStatements"]>[0]): readonly string[];
+    jsonZodSchema({ variables, }: Parameters<Type["jsonZodSchema"]>[0]): ReturnType<Type["jsonZodSchema"]>;
+    propertyFromRdfResourceValueExpression({ variables, }: Parameters<PrimitiveType<number>["propertyFromRdfResourceValueExpression"]>[0]): string;
+    toJsonExpression({ variables, }: Parameters<PrimitiveType<Date>["toJsonExpression"]>[0]): string;
+    toRdfExpression({ variables, }: Parameters<PrimitiveType<Date>["toRdfExpression"]>[0]): string;
+}
+//# sourceMappingURL=DateTimeType.d.ts.map

package/generators/ts/DateTimeType.js

@@ -0,0 +1,58 @@
+import { PrimitiveType } from "./PrimitiveType.js";
+import { objectInitializer } from "./objectInitializer.js";
+export class DateTimeType extends PrimitiveType {
+    constructor() {
+        super(...arguments);
+        this.equalsFunction = "(left, right) => purifyHelpers.Equatable.EqualsResult.fromBooleanEqualsResult(left, right, left.getTime() === right.getTime())";
+        this.kind = "DateTimeType";
+        this.mutable = true;
+    }
+    get conversions() {
+        const conversions = [
+            {
+                conversionExpression: (value) => value,
+                sourceTypeCheckExpression: (value) => `typeof ${value} === "object" && ${value} instanceof Date`,
+                sourceTypeName: this.name,
+            },
+        ];
+        this.primitiveDefaultValue.ifJust((defaultValue) => {
+            conversions.push({
+                conversionExpression: () => `new Date("${defaultValue.toISOString()}")`,
+                sourceTypeCheckExpression: (value) => `typeof ${value} === "undefined"`,
+                sourceTypeName: "undefined",
+            });
+        });
+        return conversions;
+    }
+    get jsonName() {
+        return "string";
+    }
+    get name() {
+        return "Date";
+    }
+    fromJsonExpression({ variables, }) {
+        return `new Date(${variables.value})`;
+    }
+    hashStatements({ variables, }) {
+        return [`${variables.hasher}.update(${variables.value}.toISOString());`];
+    }
+    jsonZodSchema({ variables, }) {
+        return `${variables.zod}.string().datetime()`;
+    }
+    propertyFromRdfResourceValueExpression({ variables, }) {
+        let expression = `${variables.resourceValue}.toDate()`;
+        if (this.primitiveIn.length > 0) {
+            expression = `${expression}.chain(value => { ${this.primitiveIn.map((value) => `if (value.getTime() === ${value.getTime()}) { return purify.Either.of(value); }`).join(" ")} return purify.Left(new rdfjsResource.Resource.MistypedValueError(${objectInitializer({ actualValue: "rdfLiteral.toRdf(value)", expectedValueType: JSON.stringify(this.name), focusResource: variables.resource, predicate: variables.predicate })})); })`;
+        }
+        return expression;
+    }
+    toJsonExpression({ variables, }) {
+        return `${variables.value}.toISOString()`;
+    }
+    toRdfExpression({ variables, }) {
+        return this.primitiveDefaultValue
+            .map((defaultValue) => `${variables.value}.getTime() !== ${defaultValue.getTime()} ? ${variables.value} : undefined`)
+            .orDefault(variables.value);
+    }
+}
+//# sourceMappingURL=DateTimeType.js.map

package/generators/ts/DeclaredType.d.ts

@@ -0,0 +1,17 @@
+import type { ClassDeclarationStructure, InterfaceDeclarationStructure, ModuleDeclarationStructure, TypeAliasDeclarationStructure } from "ts-morph";
+import type { TsFeature } from "../../enums/index.js";
+import type { Import } from "./Import.js";
+import { Type } from "./Type.js";
+export declare abstract class DeclaredType extends Type {
+    abstract readonly declarationImports: readonly Import[];
+    abstract readonly declarations: readonly (ClassDeclarationStructure | InterfaceDeclarationStructure | ModuleDeclarationStructure | TypeAliasDeclarationStructure)[];
+    readonly export: boolean;
+    readonly features: Set<TsFeature>;
+    readonly name: string;
+    constructor({ export_, features, name, ...superParameters }: {
+        export_: boolean;
+        features: Set<TsFeature>;
+        name: string;
+    } & ConstructorParameters<typeof Type>[0]);
+}
+//# sourceMappingURL=DeclaredType.d.ts.map

package/generators/ts/DeclaredType.js

@@ -0,0 +1,10 @@
+import { Type } from "./Type.js";
+export class DeclaredType extends Type {
+    constructor({ export_, features, name, ...superParameters }) {
+        super(superParameters);
+        this.export = export_;
+        this.features = features;
+        this.name = name;
+    }
+}
+//# sourceMappingURL=DeclaredType.js.map

package/generators/ts/IdentifierType.d.ts

@@ -1,23 +1,13 @@
 import type { BlankNode, NamedNode } from "@rdfjs/types";
-import { Maybe } from "purify-ts";
-import { NodeKind } from "shacl-ast";
-import { RdfjsTermType } from "./RdfjsTermType.js";
-import type { Type } from "./Type";
-export declare class IdentifierType extends RdfjsTermType<BlankNode | NamedNode> {
+import { TermType } from "./TermType.js";
+export declare class IdentifierType extends TermType<BlankNode | NamedNode> {
     readonly kind = "IdentifierType";
-    private readonly nodeKinds;
-    constructor({ nodeKinds, ...superParameters }: {
-        nodeKinds: Set<NodeKind.BLANK_NODE | NodeKind.IRI>;
-    } & ConstructorParameters<typeof RdfjsTermType<BlankNode | NamedNode>>[0]);
-    get conversions(): readonly Type.Conversion[];
-    get discriminatorProperty(): Maybe<Type.DiscriminatorProperty>;
     get isNamedNodeKind(): boolean;
+    get jsonName(): string;
     get name(): string;
-    hashStatements({ variables, }: Parameters<Type["hashStatements"]>[0]): readonly string[];
-    protected fromRdfResourceValueExpression({ variables, }: {
-        variables: {
-            resourceValue: string;
-        };
-    }): string;
+    fromJsonExpression({ variables, }: Parameters<TermType<BlankNode | NamedNode>["fromJsonExpression"]>[0]): string;
+    jsonZodSchema({ variables, }: Parameters<TermType<BlankNode | NamedNode>["jsonZodSchema"]>[0]): ReturnType<TermType<BlankNode | NamedNode>["jsonZodSchema"]>;
+    toJsonExpression({ variables, }: Parameters<TermType<BlankNode | NamedNode>["toJsonExpression"]>[0]): string;
+    protected propertyFromRdfResourceValueExpression({ variables, }: Parameters<TermType<BlankNode | NamedNode>["propertyFromRdfResourceValueExpression"]>[0]): string;
 }
 //# sourceMappingURL=IdentifierType.d.ts.map

package/generators/ts/IdentifierType.js

@@ -4,77 +4,86 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
-import { Maybe } from "purify-ts";
-import { NodeKind } from "shacl-ast";
-import { invariant } from "ts-invariant";
 import { Memoize } from "typescript-memoize";
-import { RdfjsTermType } from "./RdfjsTermType.js";
-import { rdfjsTermExpression } from "./rdfjsTermExpression";
-export class IdentifierType extends RdfjsTermType {
-    constructor({ nodeKinds, ...superParameters }) {
-        super(superParameters);
+import { TermType } from "./TermType.js";
+export class IdentifierType extends TermType {
+    constructor() {
+        super(...arguments);
         this.kind = "IdentifierType";
-        this.nodeKinds = new Set([...nodeKinds]);
-        invariant(this.nodeKinds.size > 0);
-    }
-    get conversions() {
-        return this.defaultValue
-            .map((defaultValue) => [
-            {
-                conversionExpression: () => rdfjsTermExpression(defaultValue, this.configuration),
-                sourceTypeName: "undefined",
-            },
-            {
-                conversionExpression: (value) => value,
-                sourceTypeCheck: (value) => `typeof ${value} === "object"`,
-                sourceTypeName: this.name,
-            },
-        ])
-            .orDefault(super.conversions);
-    }
-    get discriminatorProperty() {
-        return Maybe.of({
-            name: "termType",
-            type: "string",
-            values: [...this.nodeKinds].map((nodeKind) => {
-                switch (nodeKind) {
-                    case NodeKind.BLANK_NODE:
-                        return "BlankNode";
-                    case NodeKind.IRI:
-                        return "NamedNode";
-                }
-            }),
-        });
     }
     get isNamedNodeKind() {
-        return this.nodeKinds.size === 1 && this.nodeKinds.has(NodeKind.IRI);
+        return this.nodeKinds.size === 1 && this.nodeKinds.has("NamedNode");
+    }
+    get jsonName() {
+        if (this.in_.length > 0 && this.isNamedNodeKind) {
+            // Treat sh:in as a union of the IRIs
+            // rdfjs.NamedNode<"http://example.com/1" | "http://example.com/2">
+            return `{ readonly "@id": ${this.in_.map((iri) => `"${iri.value}"`).join(" | ")} }`;
+        }
+        return `{ readonly "@id": string }`;
     }
     get name() {
-        const names = [];
-        if (this.nodeKinds.has(NodeKind.BLANK_NODE)) {
-            names.push("rdfjs.BlankNode");
+        if (this.in_.length > 0 && this.isNamedNodeKind) {
+            // Treat sh:in as a union of the IRIs
+            // rdfjs.NamedNode<"http://example.com/1" | "http://example.com/2">
+            return `rdfjs.NamedNode<${this.in_
+                .map((iri) => `"${iri.value}"`)
+                .join(" | ")}>`;
+        }
+        return `(${[...this.nodeKinds]
+            .map((nodeKind) => `rdfjs.${nodeKind}`)
+            .join(" | ")})`;
+    }
+    fromJsonExpression({ variables, }) {
+        const valueToBlankNode = `${this.dataFactoryVariable}.blankNode(${variables.value}["@id"].substring(2))`;
+        const valueToNamedNode = `${this.dataFactoryVariable}.namedNode(${variables.value}["@id"])`;
+        if (this.nodeKinds.size === 2) {
+            return `(${variables.value}["@id"].startsWith("_:") ? ${valueToBlankNode} : ${valueToNamedNode})`;
         }
-        if (this.nodeKinds.has(NodeKind.IRI)) {
-            names.push("rdfjs.NamedNode");
+        switch ([...this.nodeKinds][0]) {
+            case "BlankNode":
+                return valueToBlankNode;
+            case "NamedNode":
+                return valueToNamedNode;
         }
-        return names.join(" | ");
     }
-    hashStatements({ variables, }) {
-        return [
-            `${variables.hasher}.update(rdfjsResource.Resource.Identifier.toString(${variables.value}));`,
-        ];
+    jsonZodSchema({ variables, }) {
+        let idSchema;
+        if (this.in_.length > 0 && this.isNamedNodeKind) {
+            // Treat sh:in as a union of the IRIs
+            // rdfjs.NamedNode<"http://example.com/1" | "http://example.com/2">
+            idSchema = `${variables.zod}.enum(${JSON.stringify(this.in_.map((iri) => iri.value))})`;
+        }
+        else {
+            idSchema = `${variables.zod}.string().min(1)`;
+        }
+        return `${variables.zod}.object({ "@id": ${idSchema} })`;
+    }
+    toJsonExpression({ variables, }) {
+        const valueToBlankNode = `{ "@id": \`_:\${${variables.value}.value}\` }`;
+        const valueToNamedNode = `{ "@id": ${variables.value}.value }`;
+        if (this.nodeKinds.size === 2) {
+            return `(${variables.value}.termType === "BlankNode" ? ${valueToBlankNode} : ${valueToNamedNode})`;
+        }
+        switch ([...this.nodeKinds][0]) {
+            case "BlankNode":
+                return valueToBlankNode;
+            case "NamedNode":
+                return valueToNamedNode;
+        }
     }
-    fromRdfResourceValueExpression({ variables, }) {
-        switch (this.name) {
-            case "rdfjs.BlankNode":
-                throw new Error("not implemented");
-            case "rdfjs.NamedNode":
-                return `${variables.resourceValue}.toIri()`;
-            case "rdfjs.BlankNode | rdfjs.NamedNode":
-                return `${variables.resourceValue}.toIdentifier()`;
-            default:
-                throw new Error(`not implemented: ${this.name}`);
+    propertyFromRdfResourceValueExpression({ variables, }) {
+        if (this.nodeKinds.size === 2) {
+            return `${variables.resourceValue}.toIdentifier()`;
+        }
+        if (this.isNamedNodeKind) {
+            let expression = `${variables.resourceValue}.toIri()`;
+            if (this.in_.length > 0) {
+                expression = `${expression}.chain(iri => { switch (iri.value) { ${this.in_.map((iri) => `case "${iri.value}": return purify.Either.of<rdfjsResource.Resource.ValueError, ${this.name}>(iri as rdfjs.NamedNode<"${iri.value}">);`).join(" ")} default: return purify.Left(new rdfjsResource.Resource.MistypedValueError({ actualValue: iri, expectedValueType: ${JSON.stringify(this.name)}, focusResource: ${variables.resource}, predicate: ${variables.predicate} })); } } )`;
+            }
+            return expression;
         }
+        throw new Error(`not implemented: ${this.name}`);
     }
 }
 __decorate([

package/generators/ts/Import.d.ts

@@ -0,0 +1,18 @@
+import { type ImportDeclarationStructure } from "ts-morph";
+export type Import = ImportDeclarationStructure | string;
+/**
+ * Singleton values for common imports.
+ */
+export declare namespace Import {
+    const PURIFY: Import;
+    const PURIFY_HELPERS: Import;
+    const RDF_LITERAL: Import;
+    const RDFJS_RESOURCE: Import;
+    const RDFJS_TYPES: Import;
+    const SHA256: Import;
+    const SPARQLJS: Import;
+    const UUID: Import;
+    const ZOD: Import;
+    const ZOD_TO_JSON_SCHEMA: Import;
+}
+//# sourceMappingURL=Import.d.ts.map

package/generators/ts/Import.js

@@ -0,0 +1,59 @@
+import { StructureKind } from "ts-morph";
+/**
+ * Singleton values for common imports.
+ */
+export var Import;
+(function (Import) {
+    Import.PURIFY = {
+        kind: StructureKind.ImportDeclaration,
+        moduleSpecifier: "purify-ts",
+        namespaceImport: "purify",
+    };
+    Import.PURIFY_HELPERS = {
+        kind: StructureKind.ImportDeclaration,
+        moduleSpecifier: "purify-ts-helpers",
+        namespaceImport: "purifyHelpers",
+    };
+    Import.RDF_LITERAL = {
+        kind: StructureKind.ImportDeclaration,
+        moduleSpecifier: "rdf-literal",
+        namespaceImport: "rdfLiteral",
+    };
+    Import.RDFJS_RESOURCE = {
+        kind: StructureKind.ImportDeclaration,
+        moduleSpecifier: "rdfjs-resource",
+        namespaceImport: "rdfjsResource",
+    };
+    Import.RDFJS_TYPES = {
+        isTypeOnly: true,
+        kind: StructureKind.ImportDeclaration,
+        moduleSpecifier: "@rdfjs/types",
+        namespaceImport: "rdfjs",
+    };
+    Import.SHA256 = {
+        kind: StructureKind.ImportDeclaration,
+        moduleSpecifier: "js-sha256",
+        namedImports: ["sha256"],
+    };
+    Import.SPARQLJS = {
+        kind: StructureKind.ImportDeclaration,
+        moduleSpecifier: "sparqljs",
+        namespaceImport: "sparqljs",
+    };
+    Import.UUID = {
+        kind: StructureKind.ImportDeclaration,
+        moduleSpecifier: "uuid",
+        namespaceImport: "uuid",
+    };
+    Import.ZOD = {
+        kind: StructureKind.ImportDeclaration,
+        moduleSpecifier: "zod",
+        namedImports: [{ alias: "zod", name: "z" }],
+    };
+    Import.ZOD_TO_JSON_SCHEMA = {
+        kind: StructureKind.ImportDeclaration,
+        moduleSpecifier: "zod-to-json-schema",
+        namedImports: [{ name: "zodToJsonSchema" }],
+    };
+})(Import || (Import = {}));
+//# sourceMappingURL=Import.js.map