@shaclmate/compiler 3.0.4 → 4.0.1

package/dist/generators/ts/_ObjectType/Property.js

@@ -1,33 +1,2 @@
-import { Scope, } from "ts-morph";
-export class Property {
-    /**
-     * TypeScript identifier-safe name of the property.
-     */
-    name;
-    /**
-     * Property type
-  .   */
-    type;
-    /**
-     * Property visibility: private, protected, public.
-     */
-    visibility;
-    objectType;
-    constructor({ name, objectType, type, visibility, }) {
-        this.name = name;
-        this.objectType = objectType;
-        this.type = type;
-        this.visibility = visibility;
-    }
-    static visibilityToScope(visibility) {
-        switch (visibility) {
-            case "private":
-                return Scope.Private;
-            case "protected":
-                return Scope.Protected;
-            case "public":
-                return undefined;
-        }
-    }
-}
+export {};
 //# sourceMappingURL=Property.js.map

package/dist/generators/ts/_ObjectType/ShaclProperty.d.ts

@@ -1,39 +1,48 @@
-import type * as rdfjs from "@rdfjs/types";
 import { Maybe } from "purify-ts";
-import type { GetAccessorDeclarationStructure, OptionalKind, PropertyDeclarationStructure, PropertySignatureStructure } from "ts-morph";
-import type { Import } from "../Import.js";
+import type { PropertyPath } from "rdfjs-resource";
 import type { Type } from "../Type.js";
-import { Property } from "./Property.js";
-export declare abstract class ShaclProperty<TypeT extends Type> extends Property<TypeT> {
-    protected readonly comment: Maybe<string>;
-    protected readonly description: Maybe<string>;
-    protected readonly label: Maybe<string>;
-    readonly path: rdfjs.NamedNode;
-    constructor({ comment, description, label, path, ...superParameters }: {
+import { type Code } from "../ts-poet-wrapper.js";
+import { AbstractProperty } from "./AbstractProperty.js";
+export declare class ShaclProperty<TypeT extends Type> extends AbstractProperty<TypeT> {
+    private readonly comment;
+    private readonly description;
+    private readonly label;
+    readonly kind = "ShaclProperty";
+    readonly mutable: boolean;
+    readonly path: PropertyPath;
+    readonly recursive: boolean;
+    constructor({ comment, description, label, mutable, path, recursive, ...superParameters }: {
         comment: Maybe<string>;
         description: Maybe<string>;
         label: Maybe<string>;
-        path: rdfjs.NamedNode;
-    } & ConstructorParameters<typeof Property<TypeT>>[0]);
-    get equalsFunction(): Maybe<string>;
-    get constructorParametersPropertySignature(): Maybe<OptionalKind<PropertySignatureStructure>>;
-    constructorStatements({ variables, }: Parameters<Property<TypeT>["constructorStatements"]>[0]): readonly string[];
-    fromJsonStatements({ variables, }: Parameters<Property<TypeT>["fromJsonStatements"]>[0]): readonly string[];
-    get getAccessorDeclaration(): Maybe<OptionalKind<GetAccessorDeclarationStructure>>;
-    hashStatements(parameters: Parameters<Property<TypeT>["hashStatements"]>[0]): readonly string[];
-    get jsonPropertySignature(): Maybe<OptionalKind<PropertySignatureStructure>>;
-    jsonUiSchemaElement({ variables, }: Parameters<Property<TypeT>["jsonUiSchemaElement"]>[0]): Maybe<string>;
-    jsonZodSchema(parameters: Parameters<Property<TypeT>["jsonZodSchema"]>[0]): ReturnType<Property<TypeT>["jsonZodSchema"]>;
-    get propertyDeclaration(): Maybe<OptionalKind<PropertyDeclarationStructure>>;
-    get declarationImports(): readonly Import[];
-    get propertySignature(): Maybe<OptionalKind<PropertySignatureStructure>>;
-    snippetDeclarations(parameters: Parameters<Property<Type>["snippetDeclarations"]>[0]): readonly string[];
-    fromRdfStatements({ variables, }: Parameters<Property<TypeT>["fromRdfStatements"]>[0]): readonly string[];
-    sparqlConstructTemplateTriples({ variables, }: Parameters<Property<TypeT>["sparqlConstructTemplateTriples"]>[0]): readonly string[];
-    sparqlWherePatterns({ variables, }: Parameters<Property<TypeT>["sparqlWherePatterns"]>[0]): readonly string[];
-    toJsonObjectMember(parameters: Parameters<Property<TypeT>["toJsonObjectMember"]>[0]): Maybe<string>;
-    toRdfStatements({ variables, }: Parameters<Property<TypeT>["toRdfStatements"]>[0]): readonly string[];
-    protected get declarationComment(): string | undefined;
-    protected get predicate(): string;
+        mutable: boolean;
+        path: PropertyPath;
+        recursive: boolean;
+    } & ConstructorParameters<typeof AbstractProperty<TypeT>>[0]);
+    get constructorParametersSignature(): Maybe<Code>;
+    get declaration(): Maybe<Code>;
+    get equalsFunction(): Maybe<Code>;
+    get filterProperty(): Maybe<{
+        name: string;
+        type: Code;
+    }>;
+    get getAccessorDeclaration(): Maybe<Code>;
+    get graphqlField(): AbstractProperty<TypeT>["graphqlField"];
+    get jsonSignature(): Maybe<Code>;
+    get jsonZodSchema(): AbstractProperty<TypeT>["jsonZodSchema"];
+    protected get schemaObject(): {
+        path: Code | undefined;
+        kind: Code;
+        type: Code;
+    };
+    constructorStatements({ variables, }: Parameters<AbstractProperty<TypeT>["constructorStatements"]>[0]): readonly Code[];
+    fromJsonStatements({ variables, }: Parameters<AbstractProperty<TypeT>["fromJsonStatements"]>[0]): readonly Code[];
+    fromRdfExpression({ variables, }: Parameters<AbstractProperty<TypeT>["fromRdfExpression"]>[0]): Maybe<Code>;
+    hashStatements(parameters: Parameters<AbstractProperty<TypeT>["hashStatements"]>[0]): readonly Code[];
+    jsonUiSchemaElement({ variables, }: Parameters<AbstractProperty<TypeT>["jsonUiSchemaElement"]>[0]): Maybe<Code>;
+    sparqlConstructTriplesExpression({ variables, }: Parameters<AbstractProperty<TypeT>["sparqlConstructTriplesExpression"]>[0]): Maybe<Code>;
+    sparqlWherePatternsExpression({ variables, }: Parameters<AbstractProperty<TypeT>["sparqlWherePatternsExpression"]>[0]): ReturnType<AbstractProperty<TypeT>["sparqlWherePatternsExpression"]>;
+    toJsonObjectMemberExpression(parameters: Parameters<AbstractProperty<TypeT>["toJsonObjectMemberExpression"]>[0]): Maybe<Code>;
+    toRdfStatements({ variables, }: Parameters<AbstractProperty<TypeT>["toRdfStatements"]>[0]): readonly Code[];
 }
 //# sourceMappingURL=ShaclProperty.d.ts.map

package/dist/generators/ts/_ObjectType/ShaclProperty.js

@@ -4,54 +4,142 @@ 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 { pascalCase } from "change-case";
 import { Maybe } from "purify-ts";
 import { Memoize } from "typescript-memoize";
+import { codeEquals } from "../codeEquals.js";
+import { rdfjsTermExpression } from "../rdfjsTermExpression.js";
+import { snippets } from "../snippets.js";
 import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
+import { code, joinCode, literalOf } from "../ts-poet-wrapper.js";
 import { tsComment } from "../tsComment.js";
-import { Property } from "./Property.js";
-export class ShaclProperty extends Property {
+import { AbstractProperty } from "./AbstractProperty.js";
+function propertyPathToCode(propertyPath) {
+    switch (propertyPath.termType) {
+        case "AlternativePath":
+        case "SequencePath":
+            return code `{ members: [${joinCode(propertyPath.members.map(propertyPathToCode), { on: "," })}] as const, termType: ${literalOf(propertyPath.termType)} as const }`;
+        case "InversePath":
+        case "OneOrMorePath":
+        case "ZeroOrMorePath":
+        case "ZeroOrOnePath":
+            return code `{ path: ${propertyPathToCode(propertyPath.path)}, termType: ${literalOf(propertyPath.termType)} as const }`;
+        case "NamedNode":
+            return rdfjsTermExpression(propertyPath);
+    }
+}
+export class ShaclProperty extends AbstractProperty {
     comment;
     description;
     label;
+    kind = "ShaclProperty";
+    mutable;
     path;
-    constructor({ comment, description, label, path, ...superParameters }) {
+    recursive;
+    constructor({ comment, description, label, mutable, path, recursive, ...superParameters }) {
         super(superParameters);
         this.comment = comment;
         this.description = description;
         this.label = label;
+        this.mutable = mutable;
         this.path = path;
+        this.recursive = recursive;
     }
-    get equalsFunction() {
-        return Maybe.of(this.type.equalsFunction);
-    }
-    get constructorParametersPropertySignature() {
+    get constructorParametersSignature() {
         let hasQuestionToken = false;
-        const typeNames = new Set(); // Remove duplicates with a set
+        const typeNames = [];
         for (const conversion of this.type.conversions) {
-            if (conversion.sourceTypeName === "undefined") {
+            if (conversion.sourceTypeof === "undefined") {
                 hasQuestionToken = true;
             }
-            else {
-                typeNames.add(conversion.sourceTypeName);
+            else if (!typeNames.some((typeName) => codeEquals(typeName, conversion.sourceTypeName))) {
+                typeNames.push(code `${conversion.sourceTypeName}`);
             }
         }
+        return Maybe.of(code `readonly ${this.name}${hasQuestionToken ? "?" : ""}: ${joinCode(typeNames, { on: "|" })};`);
+    }
+    get declaration() {
+        const lhs = [];
+        if (this.objectType.declarationType === "class" &&
+            this.visibility !== "public") {
+            lhs.push(code `${this.visibility}`);
+        }
+        if (!this.mutable) {
+            lhs.push(code `readonly`);
+        }
+        lhs.push(code `${this.name}`);
+        return Maybe.of(code `${this.comment
+            .alt(this.description)
+            .alt(this.label)
+            .map(tsComment)
+            .orDefault("")}${joinCode(lhs, { on: " " })}: ${this.type.name};`);
+    }
+    get equalsFunction() {
+        return Maybe.of(this.type.equalsFunction);
+    }
+    get filterProperty() {
+        if (this.visibility !== "public") {
+            return Maybe.empty();
+        }
+        return Maybe.of({
+            name: this.name,
+            type: this.type.filterType,
+        });
+    }
+    get getAccessorDeclaration() {
+        return Maybe.empty();
+    }
+    get graphqlField() {
+        const args = this.type.graphqlArgs;
+        const argsVariable = args.isJust() ? code `args` : code `_args`;
         return Maybe.of({
-            hasQuestionToken,
-            isReadonly: true,
-            leadingTrivia: this.declarationComment,
+            args,
+            description: this.comment.map(JSON.stringify),
             name: this.name,
-            type: [...typeNames].sort().join(" | "),
+            resolve: code `(source, ${argsVariable}) => ${this.type.graphqlResolveExpression({ variables: { args: argsVariable, value: code `source.${this.name}` } })}`,
+            type: this.type.graphqlType.name,
+        });
+    }
+    get jsonSignature() {
+        const typeJsonType = this.type.jsonType();
+        return Maybe.of(code `readonly ${this.name}${typeJsonType.optional ? "?" : ""}: ${typeJsonType.requiredName}`);
+    }
+    get jsonZodSchema() {
+        let schema = this.type.jsonZodSchema({
+            context: "property",
+        });
+        this.comment.alt(this.description).ifJust((description) => {
+            schema = code `${schema}.describe(${literalOf(description)})`;
         });
+        return Maybe.of({
+            key: this.name,
+            schema,
+        });
+    }
+    get schemaObject() {
+        return {
+            ...super.schemaObject,
+            // comment: this.comment.map(JSON.stringify).extract(),
+            // description: this.description.map(JSON.stringify).extract(),
+            path: this.objectType.features.has("rdf")
+                ? propertyPathToCode(this.path)
+                : undefined,
+            // label: this.label.map(JSON.stringify).extract(),
+            // mutable: this.mutable ? true : undefined,
+            // recursive: this.recursive ? true : undefined,
+            // visibility:
+            //   this.visibility !== "public"
+            //     ? `${JSON.stringify(this.visibility)} as const`
+            //     : undefined,
+        };
     }
     constructorStatements({ variables, }) {
         const typeConversions = this.type.conversions;
         if (typeConversions.length === 1) {
             switch (this.objectType.declarationType) {
                 case "class":
-                    return [`this.${this.name} = ${variables.parameter};`];
+                    return [code `this.${this.name} = ${variables.parameter};`];
                 case "interface":
-                    return [`const ${this.name} = ${variables.parameter};`];
+                    return [code `const ${this.name} = ${variables.parameter};`];
             }
         }
         let lhs;
@@ -61,163 +149,119 @@ export class ShaclProperty extends Property {
                 lhs = `this.${this.name}`;
                 break;
             case "interface":
-                lhs = this.name;
-                statements.push(`let ${this.name}: ${this.type.name};`);
+                lhs = `${this.name}`;
+                statements.push(code `let ${this.name}: ${this.type.name};`);
                 break;
         }
-        statements.push(typeConversions
-            .map((conversion) => `if (${conversion.sourceTypeCheckExpression(variables.parameter)}) { ${lhs} = ${conversion.conversionExpression(variables.parameter)}; }`)
+        statements.push(joinCode(typeConversions
+            .map((conversion) => code `if (${conversion.sourceTypeCheckExpression(variables.parameter)}) { ${lhs} = ${conversion.conversionExpression(variables.parameter)}; }`)
             // We shouldn't need this else, since the parameter now has the never type, but have to add it to appease the TypeScript compiler
-            .concat(`{ ${lhs} = (${variables.parameter}) satisfies never; }`)
-            .join(" else "));
+            .concat(code `{ ${lhs} = (${variables.parameter}) satisfies never; }`), { on: " else " }));
         return statements;
     }
     fromJsonStatements({ variables, }) {
         return [
-            `const ${this.name} = ${this.type.fromJsonExpression({ variables: { value: `${variables.jsonObject}["${this.name}"]` } })};`,
+            code `const ${this.name} = ${this.type.fromJsonExpression({ variables: { value: code `${variables.jsonObject}["${this.name}"]` } })};`,
         ];
     }
-    get getAccessorDeclaration() {
-        return Maybe.empty();
+    fromRdfExpression({ variables, }) {
+        // Assume the property has the correct range and ignore the object's RDF type.
+        // This also accommodates the case where the object of a property is a dangling identifier that's not the
+        // subject of any statements.
+        return Maybe.of(code `${snippets.shaclPropertyFromRdf}(${{
+            graph: variables.graph,
+            resource: variables.resource,
+            propertySchema: code `${syntheticNamePrefix}schema.properties.${this.name}`,
+            typeFromRdf: code `((resourceValues) => ${this.type.fromRdfExpression({
+                variables: {
+                    ...variables,
+                    ignoreRdfType: true,
+                    propertyPath: code `${this.objectType.staticModuleName}.${syntheticNamePrefix}schema.properties.${this.name}.path`,
+                    resourceValues: code `resourceValues`,
+                },
+            })})`,
+        }})`);
     }
     hashStatements(parameters) {
         return this.type.hashStatements(parameters);
     }
-    get jsonPropertySignature() {
-        return Maybe.of({
-            hasQuestionToken: this.type.jsonName.optional,
-            isReadonly: true,
-            name: this.name,
-            type: this.type.jsonName.requiredName,
-        });
-    }
     jsonUiSchemaElement({ variables, }) {
-        const scope = `\`\${${variables.scopePrefix}}/properties/${this.name}\``;
+        const scope = code `\`\${${variables.scopePrefix}}/properties/${this.name}\``;
         return this.type
             .jsonUiSchemaElement({ variables: { scopePrefix: scope } })
-            .altLazy(() => Maybe.of(`{ ${this.label.isJust() ? `label: "${this.label.unsafeCoerce()}", ` : ""}scope: ${scope}, type: "Control" }`));
-    }
-    jsonZodSchema(parameters) {
-        let schema = this.type.jsonZodSchema({
-            ...parameters,
-            context: "property",
-        });
-        this.comment.alt(this.description).ifJust((description) => {
-            schema = `${schema}.describe(${JSON.stringify(description)})`;
-        });
-        return Maybe.of({
-            key: this.name,
-            schema,
-        });
-    }
-    get propertyDeclaration() {
-        return Maybe.of({
-            isReadonly: !this.mutable,
-            leadingTrivia: this.declarationComment,
-            name: this.name,
-            scope: ShaclProperty.visibilityToScope(this.visibility),
-            type: this.type.name,
-        });
+            .altLazy(() => Maybe.of(code `{ ${this.label.isJust() ? `label: "${this.label.unsafeCoerce()}", ` : ""}scope: ${scope}, type: "Control" }`));
     }
-    get declarationImports() {
-        return this.type.useImports({ features: this.objectType.features });
+    sparqlConstructTriplesExpression({ variables, }) {
+        return Maybe.of(code `${snippets.shaclPropertySparqlConstructTriples}(${{
+            filter: this.filterProperty
+                .map(({ name }) => code `${variables.filter}?.${name}`)
+                .extract(),
+            focusIdentifier: variables.focusIdentifier,
+            ignoreRdfType: true,
+            propertyName: this.name,
+            propertySchema: code `${syntheticNamePrefix}schema.properties.${this.name}`,
+            typeSparqlConstructTriples: this.type.sparqlConstructTriplesFunction,
+            variablePrefix: variables.variablePrefix,
+        }})`);
     }
-    get propertySignature() {
+    sparqlWherePatternsExpression({ variables, }) {
         return Maybe.of({
-            isReadonly: !this.mutable,
-            leadingTrivia: this.declarationComment,
-            name: this.name,
-            type: this.type.name,
-        });
-    }
-    snippetDeclarations(parameters) {
-        return this.type.snippetDeclarations(parameters);
-    }
-    fromRdfStatements({ variables, }) {
-        // Assume the property has the correct range and ignore the object's RDF type.
-        // This also accommodates the case where the object of a property is a dangling identifier that's not the
-        // subject of any statements.
-        const typeFromRdfExpression = this.type.fromRdfExpression({
-            variables: {
-                ...variables,
+            patterns: code `${snippets.shaclPropertySparqlWherePatterns}(${{
+                filter: this.filterProperty
+                    .map(({ name }) => code `${variables.filter}?.${name}`)
+                    .extract(),
+                focusIdentifier: variables.focusIdentifier,
                 ignoreRdfType: true,
-                predicate: this.predicate,
-                resourceValues: `purify.Either.of<Error, rdfjsResource.Resource.Values<rdfjsResource.Resource.Value>>(${variables.resource}.values(${syntheticNamePrefix}properties.${this.name}["identifier"], { unique: true }))`,
-            },
-        });
-        return [
-            `const _${this.name}Either: purify.Either<Error, ${this.type.name}> = ${typeFromRdfExpression}.chain(values => values.head());`,
-            `if (_${this.name}Either.isLeft()) { return _${this.name}Either; }`,
-            `const ${this.name} = _${this.name}Either.unsafeCoerce();`,
-        ];
-    }
-    sparqlConstructTemplateTriples({ variables, }) {
-        const objectString = `\`\${${variables.variablePrefix}}${pascalCase(this.name)}\``;
-        return this.type.sparqlConstructTemplateTriples({
-            allowIgnoreRdfType: true,
-            context: "object",
-            variables: {
-                object: `dataFactory.variable!(${objectString})`,
-                predicate: this.predicate,
-                subject: variables.subject,
-                variablePrefix: objectString,
-            },
-        });
-    }
-    sparqlWherePatterns({ variables, }) {
-        const objectString = `\`\${${variables.variablePrefix}}${pascalCase(this.name)}\``;
-        return this.type.sparqlWherePatterns({
-            allowIgnoreRdfType: true,
-            context: "object",
-            variables: {
-                object: `dataFactory.variable!(${objectString})`,
-                predicate: this.predicate,
                 preferredLanguages: variables.preferredLanguages,
-                subject: variables.subject,
-                variablePrefix: objectString,
-            },
+                propertyName: this.name,
+                propertySchema: code `${syntheticNamePrefix}schema.properties.${this.name}`,
+                typeSparqlWherePatterns: this.type.sparqlWherePatternsFunction,
+                variablePrefix: variables.variablePrefix,
+            }})`,
         });
     }
-    toJsonObjectMember(parameters) {
-        return Maybe.of(`${this.name}: ${this.type.toJsonExpression(parameters)}`);
+    toJsonObjectMemberExpression(parameters) {
+        return Maybe.of(code `${this.name}: ${this.type.toJsonExpression(parameters)}`);
     }
     toRdfStatements({ variables, }) {
+        switch (this.path.termType) {
+            case "NamedNode":
+                break;
+            case "InversePath":
+                if (this.path.path.termType === "NamedNode") {
+                    break;
+                }
+                return [];
+            default:
+                return [];
+        }
+        const propertyPath = propertyPathToCode(this.path);
         return [
-            `${variables.resource}.add(${this.predicate}, ...${this.type.toRdfExpression({
-                variables: { ...variables, predicate: this.predicate },
-            })});`,
+            code `${variables.resource}.add(${propertyPath}, ${this.type.toRdfExpression({
+                variables: { ...variables, propertyPath },
+            })}, ${variables.graph});`,
         ];
     }
-    get declarationComment() {
-        return this.comment
-            .alt(this.description)
-            .alt(this.label)
-            .map(tsComment)
-            .extract();
-    }
-    get predicate() {
-        return `${this.objectType.staticModuleName}.${syntheticNamePrefix}properties.${this.name}["identifier"]`;
-    }
 }
 __decorate([
     Memoize()
-], ShaclProperty.prototype, "equalsFunction", null);
+], ShaclProperty.prototype, "constructorParametersSignature", null);
 __decorate([
     Memoize()
-], ShaclProperty.prototype, "constructorParametersPropertySignature", null);
+], ShaclProperty.prototype, "declaration", null);
 __decorate([
     Memoize()
-], ShaclProperty.prototype, "jsonPropertySignature", null);
+], ShaclProperty.prototype, "equalsFunction", null);
 __decorate([
     Memoize()
-], ShaclProperty.prototype, "propertyDeclaration", null);
+], ShaclProperty.prototype, "filterProperty", null);
 __decorate([
     Memoize()
-], ShaclProperty.prototype, "declarationImports", null);
+], ShaclProperty.prototype, "graphqlField", null);
 __decorate([
     Memoize()
-], ShaclProperty.prototype, "propertySignature", null);
+], ShaclProperty.prototype, "jsonSignature", null);
 __decorate([
     Memoize()
-], ShaclProperty.prototype, "predicate", null);
+], ShaclProperty.prototype, "jsonZodSchema", null);
 //# sourceMappingURL=ShaclProperty.js.map

package/dist/generators/ts/_ObjectType/TypeDiscriminantProperty.d.ts

@@ -0,0 +1,48 @@
+import { Maybe } from "purify-ts";
+import { type Code } from "../ts-poet-wrapper.js";
+import { AbstractProperty } from "./AbstractProperty.js";
+export declare class TypeDiscriminantProperty extends AbstractProperty<TypeDiscriminantProperty.Type> {
+    readonly constructorParametersSignature: Maybe<Code>;
+    readonly equalsFunction: Maybe<Code>;
+    readonly filterProperty: AbstractProperty<TypeDiscriminantProperty.Type>["filterProperty"];
+    readonly getAccessorDeclaration: Maybe<Code>;
+    readonly graphqlField: AbstractProperty<TypeDiscriminantProperty.Type>["graphqlField"];
+    readonly kind = "TypeDiscriminantProperty";
+    readonly mutable = false;
+    readonly recursive = false;
+    constructor({ type, ...superParameters }: {
+        type: TypeDiscriminantProperty.Type;
+    } & ConstructorParameters<typeof AbstractProperty>[0]);
+    get declaration(): Maybe<Code>;
+    get jsonSignature(): Maybe<Code>;
+    get jsonZodSchema(): AbstractProperty<TypeDiscriminantProperty.Type>["jsonZodSchema"];
+    private get abstract();
+    private get initializer();
+    private get override();
+    constructorStatements(): readonly Code[];
+    fromJsonStatements(): readonly Code[];
+    fromRdfExpression(): Maybe<Code>;
+    hashStatements({ variables, }: Parameters<AbstractProperty<TypeDiscriminantProperty.Type>["hashStatements"]>[0]): readonly Code[];
+    jsonUiSchemaElement({ variables, }: Parameters<AbstractProperty<TypeDiscriminantProperty.Type>["jsonUiSchemaElement"]>[0]): Maybe<Code>;
+    sparqlConstructTriplesExpression(): Maybe<Code>;
+    sparqlWherePatternsExpression(): ReturnType<AbstractProperty<TypeDiscriminantProperty.Type>["sparqlWherePatternsExpression"]>;
+    toJsonObjectMemberExpression({ variables, }: Parameters<AbstractProperty<TypeDiscriminantProperty.Type>["toJsonObjectMemberExpression"]>[0]): Maybe<Code>;
+    toRdfStatements(): readonly Code[];
+}
+export declare namespace TypeDiscriminantProperty {
+    class Type {
+        readonly filterFunction: Code;
+        readonly mutable: boolean;
+        readonly descendantValues: readonly string[];
+        readonly ownValues: readonly string[];
+        constructor({ descendantValues, mutable, ownValues, }: {
+            descendantValues: readonly string[];
+            mutable: boolean;
+            ownValues: readonly string[];
+        });
+        get name(): string;
+        get schema(): Code;
+        get values(): string[];
+    }
+}
+//# sourceMappingURL=TypeDiscriminantProperty.d.ts.map