@shaclmate/compiler 4.0.48 → 4.0.50

package/dist/generators/ts/AbstractIdentifierType.js

@@ -1,25 +0,0 @@
-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 { AbstractTermType } from "./AbstractTermType.js";
-import { code } from "./ts-poet-wrapper.js";
-export class AbstractIdentifierType extends AbstractTermType {
-    jsTypes = [
-        { instanceof: "Object", typeof: "object" },
-    ];
-    stringifyFunction = code `${this.reusables.imports.NTriplesTerm}.stringify`;
-    get graphqlType() {
-        return new AbstractTermType.GraphqlType(code `${this.reusables.imports.GraphQLString}`, this.reusables);
-    }
-    graphqlResolveExpression({ variables: { value }, }) {
-        return code `${this.reusables.imports.NTriplesTerm}.stringify(${value})`;
-    }
-}
-__decorate([
-    Memoize()
-], AbstractIdentifierType.prototype, "graphqlType", null);
-//# sourceMappingURL=AbstractIdentifierType.js.map

package/dist/generators/ts/AbstractLazyType.d.ts

@@ -1,67 +0,0 @@
-import { Maybe } from "purify-ts";
-import { AbstractType } from "./AbstractType.js";
-import type { ObjectType } from "./ObjectType.js";
-import type { ObjectUnionType } from "./ObjectUnionType.js";
-import type { OptionType } from "./OptionType.js";
-import type { SetType } from "./SetType.js";
-import { type Code } from "./ts-poet-wrapper.js";
-export declare abstract class AbstractLazyType<PartialTypeT extends AbstractLazyType.PartialTypeConstraint, ResolveTypeT extends AbstractLazyType.ResolveTypeConstraint> extends AbstractType {
-    protected readonly partialType: PartialTypeT;
-    protected readonly resolveType: ResolveTypeT;
-    protected abstract readonly runtimeClass: {
-        readonly name: Code;
-        readonly partialPropertyName: string;
-        readonly rawName: Code;
-    };
-    readonly declaration: Maybe<Code>;
-    readonly discriminantProperty: AbstractType["discriminantProperty"];
-    readonly mutable = false;
-    readonly validationFunction: Maybe<Code>;
-    constructor({ partialType, resolveType, ...superParameters }: {
-        partialType: PartialTypeT;
-        resolveType: ResolveTypeT;
-    } & ConstructorParameters<typeof AbstractType>[0]);
-    get equalsFunction(): Code;
-    get expression(): Code;
-    get filterFunction(): Code;
-    get filterType(): Code;
-    get graphqlType(): AbstractType.GraphqlType;
-    get hashFunction(): Code;
-    get jsTypes(): readonly AbstractType.JsType[];
-    get recursive(): boolean;
-    get referencesNamedType(): boolean;
-    get schemaType(): Code;
-    get toRdfResourceValueTypes(): AbstractType["toRdfResourceValueTypes"];
-    get valueSparqlConstructTriplesFunction(): Code;
-    get valueSparqlWherePatternsFunction(): Code;
-    protected get schemaInitializers(): readonly Code[];
-    jsonSchema(parameters: Parameters<AbstractType["jsonSchema"]>[0]): Code;
-    jsonType(parameters?: Parameters<AbstractType["jsonType"]>[0]): AbstractType.JsonType;
-    jsonUiSchemaElement(parameters: Parameters<AbstractType["jsonUiSchemaElement"]>[0]): Maybe<Code>;
-    toJsonExpression({ variables, }: Parameters<AbstractType["toJsonExpression"]>[0]): Code;
-    toRdfResourceValuesExpression({ variables, }: Parameters<AbstractType["toRdfResourceValuesExpression"]>[0]): Code;
-    toStringExpression({ variables, }: Parameters<AbstractType["toStringExpression"]>[0]): Code;
-    protected resolveToPartialFunction<ObjectTypeT extends AbstractLazyType.ItemTypeConstraint>({ partialType, resolveType, }: {
-        partialType: ObjectTypeT;
-        resolveType: ObjectTypeT;
-    }): Code;
-    protected resolvedObjectUnionTypeToPartialObjectUnionTypeConversion({ resolvedObjectUnionType, partialObjectUnionType, variables, }: {
-        resolvedObjectUnionType: ObjectUnionType;
-        partialObjectUnionType: ObjectUnionType;
-        variables: {
-            resolvedObjectUnion: Code;
-        };
-    }): Code;
-}
-export declare namespace AbstractLazyType {
-    type ItemTypeConstraint = ObjectType | ObjectUnionType;
-    type PartialTypeConstraint = ItemTypeConstraint | OptionType<ItemTypeConstraint> | SetType<ItemTypeConstraint>;
-    type ResolveTypeConstraint = PartialTypeConstraint;
-    type ConversionFunction = AbstractType.ConversionFunction;
-    type DiscriminantProperty = AbstractType.DiscriminantProperty;
-    const GraphqlType: typeof AbstractType.GraphqlType;
-    type GraphqlType = AbstractType.GraphqlType;
-    const JsonType: typeof AbstractType.JsonType;
-    type JsonType = AbstractType.JsonType;
-}
-//# sourceMappingURL=AbstractLazyType.d.ts.map

package/dist/generators/ts/AbstractLazyType.js

@@ -1,154 +0,0 @@
-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 { Maybe } from "purify-ts";
-import { invariant } from "ts-invariant";
-import { Memoize } from "typescript-memoize";
-import { AbstractType } from "./AbstractType.js";
-import { code, joinCode } from "./ts-poet-wrapper.js";
-export class AbstractLazyType extends AbstractType {
-    partialType;
-    resolveType;
-    declaration = Maybe.empty();
-    discriminantProperty = Maybe.empty();
-    mutable = false;
-    validationFunction = Maybe.empty();
-    constructor({ partialType, resolveType, ...superParameters }) {
-        super(superParameters);
-        this.partialType = partialType;
-        this.resolveType = resolveType;
-    }
-    get equalsFunction() {
-        return code `((left, right) => ${this.partialType.equalsFunction}(left.${this.runtimeClass.partialPropertyName}, right.${this.runtimeClass.partialPropertyName}))`;
-    }
-    get expression() {
-        return this.runtimeClass.name;
-    }
-    get filterFunction() {
-        return code `((filter: ${this.filterType}, value: ${this.expression}) => ${this.partialType.filterFunction}(filter, value.${this.runtimeClass.partialPropertyName}))`;
-    }
-    get filterType() {
-        return this.partialType.filterType;
-    }
-    get graphqlType() {
-        return this.resolveType.graphqlType;
-    }
-    get hashFunction() {
-        return code `((hasher, value) => ${this.partialType.hashFunction}(hasher, value.${this.runtimeClass.partialPropertyName}))`;
-    }
-    get jsTypes() {
-        return [
-            {
-                className: this.runtimeClass.rawName,
-                instanceof: "class",
-                typeof: "object",
-            },
-        ];
-    }
-    get recursive() {
-        return this.partialType.recursive;
-    }
-    get referencesNamedType() {
-        return this.partialType.referencesNamedType;
-    }
-    get schemaType() {
-        return code `${{
-            kind: this.kind,
-            partialType: this.partialType.schemaType,
-        }}`;
-    }
-    get toRdfResourceValueTypes() {
-        return this.partialType.toRdfResourceValueTypes;
-    }
-    get valueSparqlConstructTriplesFunction() {
-        return code `(({ schema, ...otherParameters }) => ${this.partialType.valueSparqlConstructTriplesFunction}({ ...otherParameters, schema: schema.partialType }))`;
-    }
-    get valueSparqlWherePatternsFunction() {
-        return code `(({ schema, ...otherParameters }) => ${this.partialType.valueSparqlWherePatternsFunction}({ ...otherParameters, schema: schema.partialType }))`;
-    }
-    get schemaInitializers() {
-        return super.schemaInitializers.concat(code `get partialType() { return ${this.partialType.schema}; }`);
-    }
-    jsonSchema(parameters) {
-        return this.partialType.jsonSchema(parameters);
-    }
-    jsonType(parameters) {
-        return this.partialType.jsonType(parameters);
-    }
-    jsonUiSchemaElement(parameters) {
-        return this.partialType.jsonUiSchemaElement(parameters);
-    }
-    toJsonExpression({ variables, }) {
-        return this.partialType.toJsonExpression({
-            variables: {
-                value: code `${variables.value}.${this.runtimeClass.partialPropertyName}`,
-            },
-        });
-    }
-    toRdfResourceValuesExpression({ variables, }) {
-        return this.partialType.toRdfResourceValuesExpression({
-            variables: {
-                ...variables,
-                value: code `${variables.value}.${this.runtimeClass.partialPropertyName}`,
-            },
-        });
-    }
-    toStringExpression({ variables, }) {
-        return this.partialType.toStringExpression({
-            variables: {
-                value: code `${variables.value}.${this.runtimeClass.partialPropertyName}`,
-            },
-        });
-    }
-    resolveToPartialFunction({ partialType, resolveType, }) {
-        if (partialType.kind === "Object") {
-            return code `${partialType.name.unsafeCoerce()}.createUnsafe`;
-        }
-        invariant(partialType.kind === "ObjectUnion");
-        invariant(resolveType.kind === "ObjectUnion");
-        invariant(partialType.members.length === resolveType.members.length);
-        const caseBlocks = resolveType.members.map(({ discriminantValues }, memberI) => {
-            return code `${discriminantValues.map((discriminantPropertyValue) => `case "${discriminantPropertyValue}":`).join("\n")} return ${partialType.members[memberI].type.name.unsafeCoerce()}.createUnsafe(resolved);`;
-        });
-        caseBlocks.push(code `default: resolved satisfies never; throw new Error("unrecognized type");`);
-        return code `((resolved: ${resolveType.expression}) => { switch (resolved.${resolveType.discriminantProperty.unsafeCoerce().name}) { ${joinCode(caseBlocks)} } })`;
-    }
-    resolvedObjectUnionTypeToPartialObjectUnionTypeConversion({ resolvedObjectUnionType, partialObjectUnionType, variables, }) {
-        invariant(resolvedObjectUnionType.members.length ===
-            partialObjectUnionType.members.length);
-        const caseBlocks = resolvedObjectUnionType.members.map(({ discriminantValues }, memberI) => {
-            return code `${discriminantValues.map((discriminantPropertyValue) => `case "${discriminantPropertyValue}":`).join("\n")} return ${partialObjectUnionType.members[memberI].type.name.unsafeCoerce()}.create(${variables.resolvedObjectUnion});`;
-        });
-        caseBlocks.push(code `default: ${variables.resolvedObjectUnion} satisfies never; throw new Error("unrecognized type");`);
-        return code `switch (${variables.resolvedObjectUnion}.${resolvedObjectUnionType.discriminantProperty.unsafeCoerce().name}) { ${joinCode(caseBlocks)} }`;
-    }
-}
-__decorate([
-    Memoize()
-], AbstractLazyType.prototype, "equalsFunction", null);
-__decorate([
-    Memoize()
-], AbstractLazyType.prototype, "filterFunction", null);
-__decorate([
-    Memoize()
-], AbstractLazyType.prototype, "hashFunction", null);
-__decorate([
-    Memoize()
-], AbstractLazyType.prototype, "jsTypes", null);
-__decorate([
-    Memoize()
-], AbstractLazyType.prototype, "schemaType", null);
-__decorate([
-    Memoize()
-], AbstractLazyType.prototype, "valueSparqlConstructTriplesFunction", null);
-__decorate([
-    Memoize()
-], AbstractLazyType.prototype, "valueSparqlWherePatternsFunction", null);
-(function (AbstractLazyType) {
-    AbstractLazyType.GraphqlType = AbstractType.GraphqlType;
-    AbstractLazyType.JsonType = AbstractType.JsonType;
-})(AbstractLazyType || (AbstractLazyType = {}));
-//# sourceMappingURL=AbstractLazyType.js.map

package/dist/generators/ts/AbstractLiteralType.d.ts

@@ -1,26 +0,0 @@
-import type { Literal } from "@rdfjs/types";
-import { AbstractTermType } from "./AbstractTermType.js";
-import type { Code } from "./ts-poet-wrapper.js";
-export declare abstract class AbstractLiteralType extends AbstractTermType<Literal, Literal> {
-    protected readonly languageIn: readonly string[];
-    readonly nodeKinds: ReadonlySet<"Literal">;
-    constructor({ languageIn, ...superParameters }: {
-        languageIn: readonly string[];
-    } & ConstructorParameters<typeof AbstractTermType<Literal, Literal>>[0]);
-    /**
-     * An expression that converts a compile-time RDF/JS Literal into a runtime TypeScript literal.
-     *
-     * For example, a string would be converted to "thestring".
-     */
-    abstract literalValueExpression(literal: Literal): Code;
-}
-export declare namespace AbstractLiteralType {
-    type ConversionFunction = AbstractTermType.ConversionFunction;
-    type DiscriminantProperty = AbstractTermType.DiscriminantProperty;
-    const GraphqlType: typeof import("./AbstractType.js").AbstractType.GraphqlType;
-    type GraphqlType = AbstractTermType.GraphqlType;
-    type JsType = AbstractTermType.JsType;
-    const JsonType: typeof import("./AbstractType.js").AbstractType.JsonType;
-    type JsonType = AbstractTermType.JsonType;
-}
-//# sourceMappingURL=AbstractLiteralType.d.ts.map

package/dist/generators/ts/AbstractLiteralType.js

@@ -1,15 +0,0 @@
-import { AbstractTermType } from "./AbstractTermType.js";
-export class AbstractLiteralType extends AbstractTermType {
-    languageIn;
-    nodeKinds = nodeKinds;
-    constructor({ languageIn, ...superParameters }) {
-        super(superParameters);
-        this.languageIn = languageIn;
-    }
-}
-(function (AbstractLiteralType) {
-    AbstractLiteralType.GraphqlType = AbstractTermType.GraphqlType;
-    AbstractLiteralType.JsonType = AbstractTermType.JsonType;
-})(AbstractLiteralType || (AbstractLiteralType = {}));
-const nodeKinds = new Set(["Literal"]);
-//# sourceMappingURL=AbstractLiteralType.js.map

package/dist/generators/ts/AbstractNumericType.d.ts

@@ -1,21 +0,0 @@
-import { AbstractPrimitiveType } from "./AbstractPrimitiveType.js";
-import { type Code } from "./ts-poet-wrapper.js";
-/**
- * Abstract base class for TypeScript numeric types (bigint | number).
- */
-export declare abstract class AbstractNumericType<ValueT extends bigint | number> extends AbstractPrimitiveType<ValueT> {
-    readonly hashFunction: Code;
-    abstract readonly kind: "BigInt" | "Float" | "Int";
-    get filterFunction(): Code;
-    get filterType(): Code;
-    get schemaType(): Code;
-    get valueSparqlWherePatternsFunction(): Code;
-    protected get inlineExpression(): Code;
-    jsonSchema(_parameters: Parameters<AbstractPrimitiveType<ValueT>["jsonSchema"]>[0]): Code;
-    toRdfResourceValuesExpression({ variables, }: Parameters<AbstractPrimitiveType<string>["toRdfResourceValuesExpression"]>[0]): Code;
-}
-export declare namespace AbstractNumericType {
-    const JsonType: typeof import("./AbstractType.js").AbstractType.JsonType;
-    type JsonType = AbstractPrimitiveType.JsonType;
-}
-//# sourceMappingURL=AbstractNumericType.d.ts.map

package/dist/generators/ts/AbstractNumericType.js

@@ -1,65 +0,0 @@
-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 { AbstractPrimitiveType } from "./AbstractPrimitiveType.js";
-import { code, joinCode } from "./ts-poet-wrapper.js";
-/**
- * Abstract base class for TypeScript numeric types (bigint | number).
- */
-export class AbstractNumericType extends AbstractPrimitiveType {
-    hashFunction = code `${this.reusables.snippets.hashNumeric}`;
-    get filterFunction() {
-        return code `${this.reusables.snippets.filterNumeric}<${this.expression}>`;
-    }
-    get filterType() {
-        return code `${this.reusables.snippets.NumericFilter}<${this.expression}>`;
-    }
-    get schemaType() {
-        return code `${this.reusables.snippets.NumericSchema}<${this.expression}>`;
-    }
-    get valueSparqlWherePatternsFunction() {
-        return code `${this.reusables.snippets.numericSparqlWherePatterns}<${this.expression}>`;
-    }
-    get inlineExpression() {
-        if (this.primitiveIn.length > 0) {
-            return code `${joinCode(this.primitiveIn.map((value) => this.literalValueExpression(value)), { on: " | " })}`;
-        }
-        return code `${this.jsTypes[0].typeof}`;
-    }
-    jsonSchema(_parameters) {
-        switch (this.primitiveIn.length) {
-            case 0:
-                return code `${this.reusables.imports.z}.${this.jsTypes[0].typeof}()`;
-            case 1:
-                return code `${this.reusables.imports.z}.literal(${this.literalValueExpression(this.primitiveIn[0])})`;
-            default:
-                return code `${this.reusables.imports.z}.union([${joinCode(this.primitiveIn.map((value) => code `${this.reusables.imports.z}.literal(${this.literalValueExpression(value)})`), { on: "," })}])`;
-        }
-    }
-    toRdfResourceValuesExpression({ variables, }) {
-        return code `[${this.reusables.snippets.literalFactory}.${this.jsTypes[0].typeof}(${variables.value}, ${this.rdfjsTermExpression(this.datatype)})]`;
-    }
-}
-__decorate([
-    Memoize()
-], AbstractNumericType.prototype, "filterFunction", null);
-__decorate([
-    Memoize()
-], AbstractNumericType.prototype, "filterType", null);
-__decorate([
-    Memoize()
-], AbstractNumericType.prototype, "schemaType", null);
-__decorate([
-    Memoize()
-], AbstractNumericType.prototype, "valueSparqlWherePatternsFunction", null);
-__decorate([
-    Memoize()
-], AbstractNumericType.prototype, "inlineExpression", null);
-(function (AbstractNumericType) {
-    AbstractNumericType.JsonType = AbstractPrimitiveType.JsonType;
-})(AbstractNumericType || (AbstractNumericType = {}));
-//# sourceMappingURL=AbstractNumericType.js.map

package/dist/generators/ts/AbstractObjectSetType.d.ts

@@ -1,36 +0,0 @@
-import type { Maybe } from "purify-ts";
-import type { Logger } from "ts-log";
-import type { ObjectType } from "./ObjectType.js";
-import type { ObjectUnionType } from "./ObjectUnionType.js";
-import type { Reusables } from "./Reusables.js";
-import type { TsGenerator } from "./TsGenerator.js";
-import { type Code } from "./ts-poet-wrapper.js";
-export declare abstract class AbstractObjectSetType {
-    protected readonly configuration: TsGenerator.Configuration;
-    protected readonly logger: Logger;
-    protected readonly reusables: Reusables;
-    protected readonly namedObjectTypes: readonly ObjectType[];
-    protected readonly namedObjectUnionTypes: readonly ObjectUnionType[];
-    constructor({ configuration, logger, namedObjectTypes, namedObjectUnionTypes, reusables, }: {
-        configuration: TsGenerator.Configuration;
-        logger: Logger;
-        namedObjectTypes: readonly ObjectType[];
-        namedObjectUnionTypes: readonly ObjectUnionType[];
-        reusables: Reusables;
-    });
-    abstract readonly declaration: Code;
-    protected methodSignatures(namedObjectType: {
-        readonly filterType: Code;
-        readonly identifierTypeAlias: Code;
-        readonly name: Maybe<string>;
-        readonly objectSetMethodNames: ObjectType.ObjectSetMethodNames;
-    }, options?: {
-        parameterNamePrefix?: string;
-        queryT?: string;
-    }): Readonly<Record<keyof ObjectType.ObjectSetMethodNames, {
-        readonly name: string;
-        readonly parameters: Code;
-        readonly returnType: Code;
-    }>>;
-}
-//# sourceMappingURL=AbstractObjectSetType.d.ts.map

package/dist/generators/ts/AbstractObjectSetType.js

@@ -1,44 +0,0 @@
-import { code } from "./ts-poet-wrapper.js";
-export class AbstractObjectSetType {
-    configuration;
-    logger;
-    reusables;
-    namedObjectTypes;
-    namedObjectUnionTypes;
-    constructor({ configuration, logger, namedObjectTypes, namedObjectUnionTypes, reusables, }) {
-        this.configuration = configuration;
-        this.logger = logger;
-        this.namedObjectTypes = namedObjectTypes;
-        this.namedObjectUnionTypes = namedObjectUnionTypes;
-        this.reusables = reusables;
-    }
-    methodSignatures(namedObjectType, options) {
-        const parameterNamePrefix = options?.parameterNamePrefix ?? "";
-        const queryT = options?.queryT ??
-            `${this.configuration.syntheticNamePrefix}ObjectSet.Query`;
-        const methodNames = namedObjectType.objectSetMethodNames;
-        return {
-            object: {
-                name: methodNames.object,
-                parameters: code `${parameterNamePrefix}identifier: ${namedObjectType.identifierTypeAlias}, options?: { preferredLanguages?: readonly string[]; }`,
-                returnType: code `Promise<${this.reusables.imports.Either}<Error, ${namedObjectType.name.unsafeCoerce()}>>`,
-            },
-            objectCount: {
-                name: methodNames.objectCount,
-                parameters: code `${parameterNamePrefix}query?: Pick<${queryT}<${namedObjectType.filterType}, ${namedObjectType.identifierTypeAlias}>, "filter">`,
-                returnType: code `Promise<${this.reusables.imports.Either}<Error, number>>`,
-            },
-            objectIdentifiers: {
-                name: methodNames.objectIdentifiers,
-                parameters: code `${parameterNamePrefix}query?: ${queryT}<${namedObjectType.filterType}, ${namedObjectType.identifierTypeAlias}>`,
-                returnType: code `Promise<${this.reusables.imports.Either}<Error, readonly ${namedObjectType.identifierTypeAlias}[]>>`,
-            },
-            objects: {
-                name: methodNames.objects,
-                parameters: code `${parameterNamePrefix}query?: ${queryT}<${namedObjectType.filterType}, ${namedObjectType.identifierTypeAlias}>`,
-                returnType: code `Promise<${this.reusables.imports.Either}<Error, readonly ${namedObjectType.name.unsafeCoerce()}[]>>`,
-            },
-        };
-    }
-}
-//# sourceMappingURL=AbstractObjectSetType.js.map

package/dist/generators/ts/AbstractPrimitiveType.d.ts

@@ -1,32 +0,0 @@
-import type { Literal, NamedNode } from "@rdfjs/types";
-import { Maybe } from "purify-ts";
-import { AbstractLiteralType } from "./AbstractLiteralType.js";
-import { type Code } from "./ts-poet-wrapper.js";
-export declare abstract class AbstractPrimitiveType<ValueT extends bigint | boolean | Date | string | number> extends AbstractLiteralType {
-    protected readonly datatype: NamedNode;
-    readonly conversionFunction: Maybe<AbstractLiteralType.ConversionFunction>;
-    readonly equalsFunction: Code;
-    abstract readonly kind: "BigInt" | "Boolean" | "DateTime" | "Date" | "Float" | "Int" | "NumberType" | "String";
-    readonly primitiveIn: readonly ValueT[];
-    constructor({ datatype, primitiveIn, ...superParameters }: {
-        datatype: NamedNode;
-        primitiveIn: readonly ValueT[];
-    } & ConstructorParameters<typeof AbstractLiteralType>[0]);
-    get discriminantProperty(): Maybe<AbstractLiteralType.DiscriminantProperty>;
-    protected get schemaInitializers(): readonly Code[];
-    fromJsonExpression({ variables, }: Parameters<AbstractLiteralType["fromJsonExpression"]>[0]): Code;
-    graphqlResolveExpression({ variables, }: Parameters<AbstractLiteralType["graphqlResolveExpression"]>[0]): Code;
-    jsonType(): AbstractLiteralType.JsonType;
-    abstract literalValueExpression(literal: Literal | ValueT): Code;
-    toJsonExpression({ variables, }: Parameters<AbstractLiteralType["toJsonExpression"]>[0]): Code;
-}
-export declare namespace AbstractPrimitiveType {
-    type ConversionFunction = AbstractLiteralType.ConversionFunction;
-    type DiscriminantProperty = AbstractLiteralType.DiscriminantProperty;
-    type JsType = AbstractLiteralType.JsType;
-    const GraphqlType: typeof import("./AbstractType.js").AbstractType.GraphqlType;
-    type GraphqlType = AbstractLiteralType.GraphqlType;
-    const JsonType: typeof import("./AbstractType.js").AbstractType.JsonType;
-    type JsonType = AbstractLiteralType.JsonType;
-}
-//# sourceMappingURL=AbstractPrimitiveType.d.ts.map

package/dist/generators/ts/AbstractPrimitiveType.js

@@ -1,51 +0,0 @@
-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 { Maybe } from "purify-ts";
-import { Memoize } from "typescript-memoize";
-import { AbstractLiteralType } from "./AbstractLiteralType.js";
-import { arrayOf, code } from "./ts-poet-wrapper.js";
-export class AbstractPrimitiveType extends AbstractLiteralType {
-    datatype;
-    conversionFunction = Maybe.empty();
-    equalsFunction = code `${this.reusables.snippets.strictEquals}`;
-    primitiveIn;
-    constructor({ datatype, primitiveIn, ...superParameters }) {
-        super(superParameters);
-        this.datatype = datatype;
-        this.primitiveIn = primitiveIn;
-    }
-    get discriminantProperty() {
-        return Maybe.empty();
-    }
-    get schemaInitializers() {
-        let initializers = super.schemaInitializers;
-        if (this.primitiveIn.length > 0) {
-            initializers = initializers.concat(code `in: ${arrayOf(...this.primitiveIn.map((in_) => this.literalValueExpression(in_)))} as const`);
-        }
-        return initializers;
-    }
-    fromJsonExpression({ variables, }) {
-        return code `${this.reusables.imports.Either}.of<Error, ${this.expression}>(${variables.value})`;
-    }
-    graphqlResolveExpression({ variables, }) {
-        return variables.value;
-    }
-    jsonType() {
-        return new AbstractLiteralType.JsonType(this.expression);
-    }
-    toJsonExpression({ variables, }) {
-        return variables.value;
-    }
-}
-__decorate([
-    Memoize()
-], AbstractPrimitiveType.prototype, "jsonType", null);
-(function (AbstractPrimitiveType) {
-    AbstractPrimitiveType.GraphqlType = AbstractLiteralType.GraphqlType;
-    AbstractPrimitiveType.JsonType = AbstractLiteralType.JsonType;
-})(AbstractPrimitiveType || (AbstractPrimitiveType = {}));
-//# sourceMappingURL=AbstractPrimitiveType.js.map

package/dist/generators/ts/AbstractTermType.d.ts

@@ -1,50 +0,0 @@
-import type { BlankNode, Literal, NamedNode } from "@rdfjs/types";
-import { NodeKind } from "@shaclmate/shacl-ast";
-import { Maybe } from "purify-ts";
-import { AbstractType } from "./AbstractType.js";
-import { type Code } from "./ts-poet-wrapper.js";
-/**
- * Abstract base class for all types that are terms in RDF (i.e., identifiers, literals).
- *
- * ConstantTermT is the type of sh:hasValue and sh:in.
- * RuntimeTermT is the type of values at runtime.
- *
- * The two are differentiated because identifiers can have BlankNode or NamedNode values at runtime but only NamedNode values for sh:hasValue and sh:in.
- */
-export declare abstract class AbstractTermType<ConstantTermT extends Literal | NamedNode = Literal | NamedNode, _RuntimeTermT extends BlankNode | Literal | NamedNode = BlankNode | Literal | NamedNode> extends AbstractType {
-    protected abstract readonly inlineExpression: Code;
-    readonly equalsFunction: Code;
-    readonly graphqlArgs: AbstractType["graphqlArgs"];
-    readonly hasValues: readonly ConstantTermT[];
-    readonly hashFunction: Code;
-    readonly in_: readonly ConstantTermT[];
-    readonly mutable: boolean;
-    abstract readonly nodeKinds: ReadonlySet<NodeKind>;
-    readonly recursive = false;
-    readonly validationFunction: Maybe<Code>;
-    constructor({ hasValues, in_, ...superParameters }: {
-        hasValues: readonly ConstantTermT[];
-        in_: readonly ConstantTermT[];
-    } & ConstructorParameters<typeof AbstractType>[0]);
-    get declaration(): Maybe<Code>;
-    get discriminantProperty(): Maybe<AbstractType.DiscriminantProperty>;
-    get expression(): Code;
-    get referencesNamedType(): boolean;
-    get termTypes(): ReadonlySet<"BlankNode" | "Literal" | "NamedNode">;
-    get toRdfResourceValueTypes(): Set<"BlankNode" | "Literal" | "NamedNode">;
-    get valueSparqlConstructTriplesFunction(): Code;
-    protected get schemaInitializers(): readonly Code[];
-    jsonUiSchemaElement(): Maybe<Code>;
-    toRdfResourceValuesExpression({ variables, }: Parameters<AbstractType["toRdfResourceValuesExpression"]>[0]): Code;
-    toStringExpression({ variables, }: Parameters<AbstractType["toStringExpression"]>[0]): Code;
-}
-export declare namespace AbstractTermType {
-    type ConversionFunction = AbstractType.ConversionFunction;
-    type DiscriminantProperty = AbstractType.DiscriminantProperty;
-    const GraphqlType: typeof AbstractType.GraphqlType;
-    type GraphqlType = AbstractType.GraphqlType;
-    type JsType = AbstractType.JsType;
-    const JsonType: typeof AbstractType.JsonType;
-    type JsonType = AbstractType.JsonType;
-}
-//# sourceMappingURL=AbstractTermType.d.ts.map