@shaclmate/compiler 4.0.50 → 4.0.52

package/dist/Compiler.d.ts

@@ -0,0 +1,14 @@
+import type { Either } from "purify-ts";
+import type { Logger } from "ts-log";
+import type { Generator } from "./generators/Generator.js";
+import type { ShapesGraph } from "./input/ShapesGraph.js";
+export declare class Compiler {
+    private readonly generator;
+    private readonly logger;
+    constructor({ generator, logger, }: {
+        generator: Generator;
+        logger: Logger;
+    });
+    compile(shapesGraph: ShapesGraph): Either<Error, string>;
+}
+//# sourceMappingURL=Compiler.d.ts.map

package/dist/Compiler.js

@@ -0,0 +1,18 @@
+import { ShapesGraphToAstTransformer } from "./ShapesGraphToAstTransformer.js";
+export class Compiler {
+    generator;
+    logger;
+    constructor({ generator, logger, }) {
+        this.generator = generator;
+        this.logger = logger;
+    }
+    compile(shapesGraph) {
+        return new ShapesGraphToAstTransformer({
+            logger: this.logger,
+            shapesGraph,
+        })
+            .transform()
+            .map((ast) => this.generator.generate(ast));
+    }
+}
+//# sourceMappingURL=Compiler.js.map

package/dist/Eithers.d.ts

@@ -0,0 +1,14 @@
+import type { Either } from "purify-ts";
+export declare namespace Eithers {
+    function chain2<R1, R2>(either1: Either<Error, R1>, either2: Either<Error, R2>): Either<Error, [R1, R2]>;
+    function chain3<R1, R2, R3>(either1: Either<Error, R1>, either2: Either<Error, R2>, either3: Either<Error, R3>): Either<Error, [R1, R2, R3]>;
+    function chain4<R1, R2, R3, R4>(either1: Either<Error, R1>, either2: Either<Error, R2>, either3: Either<Error, R3>, either4: Either<Error, R4>): Either<Error, [R1, R2, R3, R4]>;
+    function chain5<R1, R2, R3, R4, R5>(either1: Either<Error, R1>, either2: Either<Error, R2>, either3: Either<Error, R3>, either4: Either<Error, R4>, either5: Either<Error, R5>): Either<Error, [R1, R2, R3, R4, R5]>;
+    function chain6<R1, R2, R3, R4, R5, R6>(either1: Either<Error, R1>, either2: Either<Error, R2>, either3: Either<Error, R3>, either4: Either<Error, R4>, either5: Either<Error, R5>, either6: Either<Error, R6>): Either<Error, [R1, R2, R3, R4, R5, R6]>;
+    function chain7<R1, R2, R3, R4, R5, R6, R7>(either1: Either<Error, R1>, either2: Either<Error, R2>, either3: Either<Error, R3>, either4: Either<Error, R4>, either5: Either<Error, R5>, either6: Either<Error, R6>, either7: Either<Error, R7>): Either<Error, [R1, R2, R3, R4, R5, R6, R7]>;
+    function chain8<R1, R2, R3, R4, R5, R6, R7, R8>(either1: Either<Error, R1>, either2: Either<Error, R2>, either3: Either<Error, R3>, either4: Either<Error, R4>, either5: Either<Error, R5>, either6: Either<Error, R6>, either7: Either<Error, R7>, either8: Either<Error, R8>): Either<Error, [R1, R2, R3, R4, R5, R6, R7, R8]>;
+    function chain9<R1, R2, R3, R4, R5, R6, R7, R8, R9>(either1: Either<Error, R1>, either2: Either<Error, R2>, either3: Either<Error, R3>, either4: Either<Error, R4>, either5: Either<Error, R5>, either6: Either<Error, R6>, either7: Either<Error, R7>, either8: Either<Error, R8>, either9: Either<Error, R9>): Either<Error, [R1, R2, R3, R4, R5, R6, R7, R8, R9]>;
+    function chain10<R1, R2, R3, R4, R5, R6, R7, R8, R9, R10>(either1: Either<Error, R1>, either2: Either<Error, R2>, either3: Either<Error, R3>, either4: Either<Error, R4>, either5: Either<Error, R5>, either6: Either<Error, R6>, either7: Either<Error, R7>, either8: Either<Error, R8>, either9: Either<Error, R9>, either10: Either<Error, R10>): Either<Error, [R1, R2, R3, R4, R5, R6, R7, R8, R9, R10]>;
+    function chain11<R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11>(either1: Either<Error, R1>, either2: Either<Error, R2>, either3: Either<Error, R3>, either4: Either<Error, R4>, either5: Either<Error, R5>, either6: Either<Error, R6>, either7: Either<Error, R7>, either8: Either<Error, R8>, either9: Either<Error, R9>, either10: Either<Error, R10>, either11: Either<Error, R11>): Either<Error, [R1, R2, R3, R4, R5, R6, R7, R8, R9, R10, R11]>;
+}
+//# sourceMappingURL=Eithers.d.ts.map

package/dist/Eithers.js

@@ -0,0 +1,67 @@
+export var Eithers;
+(function (Eithers) {
+    function chain2(either1, either2) {
+        return either1.chain((r1) => either2.map((r2) => [r1, r2]));
+    }
+    Eithers.chain2 = chain2;
+    function chain3(either1, either2, either3) {
+        return either1.chain((r1) => either2.chain((r2) => either3.map((r3) => [r1, r2, r3])));
+    }
+    Eithers.chain3 = chain3;
+    function chain4(either1, either2, either3, either4) {
+        return either1.chain((r1) => either2.chain((r2) => either3.chain((r3) => either4.map((r4) => [r1, r2, r3, r4]))));
+    }
+    Eithers.chain4 = chain4;
+    function chain5(either1, either2, either3, either4, either5) {
+        return either1.chain((r1) => either2.chain((r2) => either3.chain((r3) => either4.chain((r4) => either5.map((r5) => [r1, r2, r3, r4, r5])))));
+    }
+    Eithers.chain5 = chain5;
+    function chain6(either1, either2, either3, either4, either5, either6) {
+        return either1.chain((r1) => either2.chain((r2) => either3.chain((r3) => either4.chain((r4) => either5.chain((r5) => either6.map((r6) => [r1, r2, r3, r4, r5, r6]))))));
+    }
+    Eithers.chain6 = chain6;
+    function chain7(either1, either2, either3, either4, either5, either6, either7) {
+        return either1.chain((r1) => either2.chain((r2) => either3.chain((r3) => either4.chain((r4) => either5.chain((r5) => either6.chain((r6) => either7.map((r7) => [r1, r2, r3, r4, r5, r6, r7])))))));
+    }
+    Eithers.chain7 = chain7;
+    function chain8(either1, either2, either3, either4, either5, either6, either7, either8) {
+        return either1.chain((r1) => either2.chain((r2) => either3.chain((r3) => either4.chain((r4) => either5.chain((r5) => either6.chain((r6) => either7.chain((r7) => either8.map((r8) => [r1, r2, r3, r4, r5, r6, r7, r8]))))))));
+    }
+    Eithers.chain8 = chain8;
+    function chain9(either1, either2, either3, either4, either5, either6, either7, either8, either9) {
+        return either1.chain((r1) => either2.chain((r2) => either3.chain((r3) => either4.chain((r4) => either5.chain((r5) => either6.chain((r6) => either7.chain((r7) => either8.chain((r8) => either9.map((r9) => [r1, r2, r3, r4, r5, r6, r7, r8, r9])))))))));
+    }
+    Eithers.chain9 = chain9;
+    function chain10(either1, either2, either3, either4, either5, either6, either7, either8, either9, either10) {
+        return either1.chain((r1) => either2.chain((r2) => either3.chain((r3) => either4.chain((r4) => either5.chain((r5) => either6.chain((r6) => either7.chain((r7) => either8.chain((r8) => either9.chain((r9) => either10.map((r10) => [
+            r1,
+            r2,
+            r3,
+            r4,
+            r5,
+            r6,
+            r7,
+            r8,
+            r9,
+            r10,
+        ]))))))))));
+    }
+    Eithers.chain10 = chain10;
+    function chain11(either1, either2, either3, either4, either5, either6, either7, either8, either9, either10, either11) {
+        return either1.chain((r1) => either2.chain((r2) => either3.chain((r3) => either4.chain((r4) => either5.chain((r5) => either6.chain((r6) => either7.chain((r7) => either8.chain((r8) => either9.chain((r9) => either10.chain((r10) => either11.map((r11) => [
+            r1,
+            r2,
+            r3,
+            r4,
+            r5,
+            r6,
+            r7,
+            r8,
+            r9,
+            r10,
+            r11,
+        ])))))))))));
+    }
+    Eithers.chain11 = chain11;
+})(Eithers || (Eithers = {}));
+//# sourceMappingURL=Eithers.js.map

package/dist/ShapesGraphToAstTransformer.d.ts

@@ -0,0 +1,18 @@
+import TermMap from "@rdfjs/term-map";
+import type { BlankNode, NamedNode } from "@rdfjs/types";
+import { Either } from "purify-ts";
+import type { Logger } from "ts-log";
+import type * as ast from "./ast/index.js";
+import type * as input from "./input/index.js";
+export declare class ShapesGraphToAstTransformer {
+    protected readonly cachedAstTypesByShapeIdentifier: TermMap<BlankNode | NamedNode, ast.Type>;
+    protected readonly syntheticAstStructTypesByName: Map<string, ast.StructType>;
+    protected readonly logger: Logger;
+    protected readonly shapesGraph: input.ShapesGraph;
+    constructor({ logger, shapesGraph, }: {
+        logger: Logger;
+        shapesGraph: input.ShapesGraph;
+    });
+    transform(): Either<Error, ast.Ast>;
+}
+//# sourceMappingURL=ShapesGraphToAstTransformer.d.ts.map

package/dist/ShapesGraphToAstTransformer.js

@@ -0,0 +1,50 @@
+import TermMap from "@rdfjs/term-map";
+import { Either } from "purify-ts";
+import { ShapeStack } from "./_ShapesGraphToAstTransformer/ShapeStack.js";
+import { transformShapeToAstType } from "./_ShapesGraphToAstTransformer/transformShapeToAstType.js";
+export class ShapesGraphToAstTransformer {
+    // Members are protected so they're accessible to functions in other files
+    cachedAstTypesByShapeIdentifier = new TermMap();
+    syntheticAstStructTypesByName = new Map();
+    logger;
+    shapesGraph;
+    constructor({ logger, shapesGraph, }) {
+        this.logger = logger;
+        this.shapesGraph = shapesGraph;
+    }
+    transform() {
+        const astNamedTypes = [];
+        for (const nodeShape of this.shapesGraph.nodeShapes) {
+            if (nodeShape.$identifier().termType !== "NamedNode") {
+                continue;
+            }
+            if (nodeShape.ignore) {
+                continue;
+            }
+            const nodeShapeAstTypeEither = transformShapeToAstType.call(this, nodeShape, new ShapeStack());
+            if (nodeShapeAstTypeEither.isLeft()) {
+                return nodeShapeAstTypeEither;
+            }
+            const nodeShapeAstType = nodeShapeAstTypeEither.unsafeCoerce();
+            nodeShapeAstType.name.ifJust(() => {
+                astNamedTypes.push(nodeShapeAstType);
+            });
+        }
+        return Either.of({
+            lazyTypesCount: [...this.cachedAstTypesByShapeIdentifier.values()].reduce((acc, astType) => {
+                switch (astType.kind) {
+                    case "Lazy":
+                    case "LazyOption":
+                    case "LazySet":
+                        return acc + 1;
+                    default:
+                        return acc;
+                }
+            }, 0),
+            namedTypes: astNamedTypes.concat([
+                ...this.syntheticAstStructTypesByName.values(),
+            ]),
+        });
+    }
+}
+//# sourceMappingURL=ShapesGraphToAstTransformer.js.map

package/dist/_ShapesGraphToAstTransformer/ShapeStack.d.ts

@@ -0,0 +1,15 @@
+import type { Literal, NamedNode } from "@rdfjs/types";
+import { Maybe } from "purify-ts";
+import type * as input from "../input/index.js";
+export declare class ShapeStack {
+    private readonly stack;
+    constructor();
+    readonly constraints: {
+        readonly hasValues: readonly (Literal | NamedNode)[];
+        readonly in_: readonly (Literal | NamedNode)[];
+    };
+    get defaultValue(): Maybe<Literal | NamedNode>;
+    pop(shape: input.Shape): this;
+    push(shape: input.Shape): this;
+}
+//# sourceMappingURL=ShapeStack.d.ts.map

package/dist/_ShapesGraphToAstTransformer/ShapeStack.js

@@ -0,0 +1,51 @@
+import { Maybe } from "purify-ts";
+import { invariant } from "ts-invariant";
+export class ShapeStack {
+    stack = [];
+    constructor() {
+        const stack = this.stack;
+        this.constraints = {
+            get hasValues() {
+                for (const shape of stack.toReversed()) {
+                    if (shape.hasValues.length > 0) {
+                        return shape.hasValues;
+                    }
+                }
+                return [];
+            },
+            get in_() {
+                for (const shape of stack.toReversed()) {
+                    const shapeIn = shape.in_.orDefault([]);
+                    if (shapeIn.length > 0) {
+                        return shapeIn;
+                    }
+                }
+                return [];
+            },
+        };
+    }
+    constraints;
+    get defaultValue() {
+        for (const shape of this.stack.toReversed()) {
+            if (shape.$type !== "PropertyShape") {
+                continue;
+            }
+            if (shape.defaultValue.isJust()) {
+                return shape.defaultValue;
+            }
+        }
+        return Maybe.empty();
+    }
+    pop(shape) {
+        const poppedShape = this.stack.pop();
+        invariant(poppedShape, "stack is empty");
+        invariant(Object.is(poppedShape, shape), "tried to pop wrong shape from stack");
+        return this;
+    }
+    push(shape) {
+        invariant(!this.stack.some((stackShape) => Object.is(stackShape, shape)), "shape already on stack");
+        this.stack.push(shape);
+        return this;
+    }
+}
+//# sourceMappingURL=ShapeStack.js.map

package/dist/_ShapesGraphToAstTransformer/defaultNodeShapeNodeKinds.d.ts

@@ -0,0 +1,3 @@
+import type { NodeKind } from "@shaclmate/shacl-ast";
+export declare const defaultNodeShapeNodeKinds: ReadonlySet<NodeKind>;
+//# sourceMappingURL=defaultNodeShapeNodeKinds.d.ts.map

package/dist/_ShapesGraphToAstTransformer/defaultNodeShapeNodeKinds.js

@@ -0,0 +1,5 @@
+export const defaultNodeShapeNodeKinds = new Set([
+    "BlankNode",
+    "IRI",
+]);
+//# sourceMappingURL=defaultNodeShapeNodeKinds.js.map

package/dist/_ShapesGraphToAstTransformer/shapeAstTypeName.d.ts

@@ -0,0 +1,4 @@
+import { Maybe } from "purify-ts";
+import type * as input from "../input/index.js";
+export declare function shapeAstTypeName(shape: input.Shape): Maybe<string>;
+//# sourceMappingURL=shapeAstTypeName.d.ts.map

package/dist/_ShapesGraphToAstTransformer/shapeAstTypeName.js

@@ -0,0 +1,24 @@
+import { Curie } from "@shaclmate/shacl-ast";
+import { Maybe } from "purify-ts";
+export function shapeAstTypeName(shape) {
+    if (shape.$type !== "NodeShape") {
+        return Maybe.empty();
+    }
+    const shapeIdentifier = shape.$identifier();
+    if (shapeIdentifier.termType !== "NamedNode") {
+        return Maybe.empty();
+    }
+    // Explicit shaclmate:name
+    if (shape.shaclmateName.isJust()) {
+        return shape.shaclmateName;
+    }
+    // CURIE shape identifier
+    if (shapeIdentifier instanceof Curie) {
+        if (shapeIdentifier.hasUniqueReference) {
+            return Maybe.of(shapeIdentifier.reference);
+        }
+        return Maybe.of(`${shapeIdentifier.prefix}_${shapeIdentifier.reference}`);
+    }
+    return Maybe.empty();
+}
+//# sourceMappingURL=shapeAstTypeName.js.map

package/dist/_ShapesGraphToAstTransformer/shapeNodeKinds.d.ts

@@ -0,0 +1,9 @@
+import { NodeKind } from "@shaclmate/shacl-ast";
+import { Either } from "purify-ts";
+import type * as input from "../input/index.js";
+import type { ShapesGraphToAstTransformer } from "../ShapesGraphToAstTransformer.js";
+export declare function shapeNodeKinds(this: ShapesGraphToAstTransformer, shape: input.Shape, options?: {
+    defaultNodeShapeNodeKinds: ReadonlySet<NodeKind>;
+    defaultPropertyShapeNodeKinds?: ReadonlySet<NodeKind>;
+}): Either<Error, ReadonlySet<NodeKind>>;
+//# sourceMappingURL=shapeNodeKinds.d.ts.map

package/dist/_ShapesGraphToAstTransformer/shapeNodeKinds.js

@@ -0,0 +1,150 @@
+import { NodeKind } from "@shaclmate/shacl-ast";
+import { Either, Left } from "purify-ts";
+import { defaultNodeShapeNodeKinds } from "./defaultNodeShapeNodeKinds.js";
+const defaultPropertyShapeNodeKinds = new Set([
+    "BlankNode",
+    "IRI",
+    "Literal",
+]);
+export function shapeNodeKinds(shape, options) {
+    const explicitNodeKinds = shape.nodeKind
+        .map(NodeKind.fromIri)
+        .orDefault(new Set());
+    // Consider constraints that dictate certain node kinds, like sh:datatype dictates a Literal nodeKind.
+    const constraintExcludeNodeKinds = new Set();
+    const constraintIncludeNodeKinds = new Set();
+    for (const [constraint, { excludeNodeKinds, includeNodeKinds }] of [
+        [
+            "sh:class",
+            shape.classes.length > 0
+                ? { excludeNodeKinds: ["Literal"] }
+                : {},
+        ],
+        [
+            "sh:datatype",
+            {
+                includeNodeKinds: shape.datatype
+                    .map(() => ["Literal"])
+                    .orDefault([]),
+            },
+        ],
+        [
+            "sh:defaultValue",
+            {
+                includeNodeKinds: shape.$type === "PropertyShape"
+                    ? shape.defaultValue
+                        .map((value) => NodeKind.fromTermType(value.termType))
+                        .toList()
+                    : [],
+            },
+        ],
+        [
+            "sh:hasValue",
+            {
+                includeNodeKinds: shape.hasValues.map((value) => NodeKind.fromTermType(value.termType)),
+            },
+        ],
+        [
+            "sh:in",
+            {
+                includeNodeKinds: shape.in_
+                    .orDefault([])
+                    .map((in_) => NodeKind.fromTermType(in_.termType)),
+            },
+        ],
+        [
+            "sh:languageIn",
+            shape.languageIn.orDefault([]).length > 0
+                ? { includeNodeKinds: ["Literal"] }
+                : {},
+        ],
+        [
+            "sh:maxExclusive",
+            {
+                includeNodeKinds: shape.maxExclusive
+                    .map(() => ["Literal"])
+                    .orDefault([]),
+            },
+        ],
+        [
+            "sh:maxInclusive",
+            {
+                includeNodeKinds: shape.maxInclusive
+                    .map(() => ["Literal"])
+                    .orDefault([]),
+            },
+        ],
+        [
+            "sh:minExclusive",
+            {
+                includeNodeKinds: shape.minExclusive
+                    .map(() => ["Literal"])
+                    .orDefault([]),
+            },
+        ],
+        [
+            "sh:minInclusive",
+            {
+                includeNodeKinds: shape.minInclusive
+                    .map(() => ["Literal"])
+                    .orDefault([]),
+            },
+        ],
+    ]) {
+        for (const excludeNodeKind of excludeNodeKinds ?? []) {
+            if (explicitNodeKinds.size > 0 &&
+                explicitNodeKinds.has(excludeNodeKind)) {
+                return Left(new Error(`${shape} has ${constraint} that conflicts with sh:nodeKind`));
+            }
+            constraintExcludeNodeKinds.add(excludeNodeKind);
+        }
+        for (const includeNodeKind of includeNodeKinds ?? []) {
+            if (explicitNodeKinds.size > 0 &&
+                !explicitNodeKinds.has(includeNodeKind)) {
+                return Left(new Error(`${shape} has ${constraint} that conflicts with sh:nodeKind`));
+            }
+            constraintIncludeNodeKinds.add(includeNodeKind);
+        }
+    }
+    if (explicitNodeKinds.size > 0) {
+        return Either.of(explicitNodeKinds);
+    }
+    // There were no explicit sh:nodeKind, try to infer the shape's node kind from the node kinds excluded and included by constraints
+    const constraintNodeKinds = new Set();
+    if (constraintIncludeNodeKinds.size > 0) {
+        // If constraints dictated/included certain node kinds be included. Add those to the set.
+        for (const constraintIncludeNodeKind of constraintIncludeNodeKinds) {
+            constraintNodeKinds.add(constraintIncludeNodeKind);
+        }
+        // Check whether other constraints' excluded node kinds conflict.
+        if (constraintExcludeNodeKinds.size > 0) {
+            for (const constraintExcludeNodeKind of constraintExcludeNodeKinds) {
+                if (constraintIncludeNodeKinds.has(constraintExcludeNodeKind)) {
+                    return Left(new Error(`${shape} has constraints with conflicting exclude/include node kinds`));
+                }
+            }
+        }
+    }
+    else if (constraintExcludeNodeKinds.size > 0) {
+        // No constraint dictated that certain node kinds be included, but some constraint dictated that certain node kinds be excluded.
+        // Start with all node kinds and exclude.
+        constraintNodeKinds.add("BlankNode");
+        constraintNodeKinds.add("IRI");
+        constraintNodeKinds.add("Literal");
+        for (const constraintExcludeNodeKind of constraintExcludeNodeKinds) {
+            constraintNodeKinds.delete(constraintExcludeNodeKind);
+        }
+    }
+    if (constraintNodeKinds.size > 0) {
+        return Either.of(constraintNodeKinds);
+    }
+    if (shape.$type === "NodeShape") {
+        return Either.of(options?.defaultNodeShapeNodeKinds ?? defaultNodeShapeNodeKinds);
+    }
+    if (shape.path.termType === "InversePath") {
+        // Inverse paths can only have blank nodes and IRIs as values, because the value is the subject of a triple.
+        return Either.of(new Set(["BlankNode", "IRI"]));
+    }
+    return Either.of(defaultPropertyShapeNodeKinds);
+}
+//# sourceMappingURL=shapeNodeKinds.js.map

package/dist/_ShapesGraphToAstTransformer/shapeOntology.d.ts

@@ -0,0 +1,5 @@
+import { Either, Maybe } from "purify-ts";
+import type * as input from "../input/index.js";
+import type { ShapesGraphToAstTransformer } from "../ShapesGraphToAstTransformer.js";
+export declare function shapeOntology(this: ShapesGraphToAstTransformer, shape: input.Shape): Either<Error, Maybe<input.Ontology>>;
+//# sourceMappingURL=shapeOntology.d.ts.map

package/dist/_ShapesGraphToAstTransformer/shapeOntology.js

@@ -0,0 +1,26 @@
+import { Either, Maybe } from "purify-ts";
+export function shapeOntology(shape) {
+    if (shape.isDefinedBy.isJust()) {
+        // If there's an rdfs:isDefinedBy statement on the shape then don't fall back to anything else
+        return this.shapesGraph
+            .ontology(shape.isDefinedBy.unsafeCoerce())
+            .map(Maybe.of);
+    }
+    // No rdfs:isDefinedBy statement on the shape
+    const ontologies = this.shapesGraph.ontologies;
+    if (ontologies.length === 1) {
+        // If there's a single ontology in the shapes graph, consider the shape a part of the ontology
+        return Either.of(Maybe.of(ontologies[0]));
+    }
+    const shapeIdentifier = shape.$identifier();
+    if (shapeIdentifier.termType === "NamedNode") {
+        const prefixOntologies = ontologies.filter((ontology) => ontology.$identifier().termType === "NamedNode" &&
+            shapeIdentifier.value.startsWith(ontology.$identifier().value));
+        if (prefixOntologies.length === 1) {
+            // If there's a single ontology whose IRI is a prefix of this shape's IRI, consider the shape a part of the ontology
+            return Either.of(Maybe.of(prefixOntologies[0]));
+        }
+    }
+    return Either.of(Maybe.empty());
+}
+//# sourceMappingURL=shapeOntology.js.map

package/dist/_ShapesGraphToAstTransformer/transformPropertyShapeToAstStructTypeField.d.ts

@@ -0,0 +1,17 @@
+import { Either, Maybe } from "purify-ts";
+import * as ast from "../ast/index.js";
+import type * as input from "../input/index.js";
+import type { ShapesGraphToAstTransformer } from "../ShapesGraphToAstTransformer.js";
+/**
+ * Try to transform a property shape to an ast.StructType.Field.
+ *
+ * Returns:
+ *  - Right<Just<ast.StructType.Field>> if the transformation succeeds
+ *  - Right<Nothing> if the property shape should be ignored
+ *  - Left<Error> if the transformation fails
+ */
+export declare function transformPropertyShapeToAstStructTypeField(this: ShapesGraphToAstTransformer, { propertyShape, structType, }: {
+    propertyShape: input.PropertyShape;
+    structType: ast.StructType;
+}): Either<Error, Maybe<ast.StructType.Field>>;
+//# sourceMappingURL=transformPropertyShapeToAstStructTypeField.d.ts.map