@shaclmate/compiler 4.0.48 → 4.0.50

package/dist/Compiler.d.ts

@@ -1,14 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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

@@ -1,14 +0,0 @@
-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

@@ -1,67 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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

@@ -1,50 +0,0 @@
-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

@@ -1,15 +0,0 @@
-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

@@ -1,51 +0,0 @@
-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

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

package/dist/_ShapesGraphToAstTransformer/defaultNodeShapeNodeKinds.js

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

package/dist/_ShapesGraphToAstTransformer/shapeAstTypeName.d.ts

@@ -1,4 +0,0 @@
-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

@@ -1,24 +0,0 @@
-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

@@ -1,9 +0,0 @@
-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

@@ -1,150 +0,0 @@
-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

@@ -1,5 +0,0 @@
-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

@@ -1,26 +0,0 @@
-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

@@ -1,17 +0,0 @@
-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