@shaclmate/compiler 3.0.4 → 4.0.1

package/dist/ast/OptionType.d.ts

@@ -1,9 +1,14 @@
-import type { Type } from "./Type.js";
+import { AbstractContainerType } from "./AbstractContainerType.js";
+import type { PlaceholderType } from "./PlaceholderType.js";
 /**
  * A type with zero or one values of an item type.
  */
-export interface OptionType<ItemTypeT extends Type = Type> {
-    readonly itemType: ItemTypeT;
-    readonly kind: "OptionType";
+export declare class OptionType<ItemTypeT extends OptionType.ItemType = OptionType.ItemType> extends AbstractContainerType<ItemTypeT> {
+    readonly kind = "OptionType";
+    constructor({ itemType, }: Pick<ConstructorParameters<typeof AbstractContainerType<ItemTypeT>>[0], "itemType">);
+}
+export declare namespace OptionType {
+    type ItemType = Exclude<AbstractContainerType.ItemType, PlaceholderType>;
+    const isItemType: typeof AbstractContainerType.isItemType;
 }
 //# sourceMappingURL=OptionType.d.ts.map

package/dist/ast/OptionType.js

@@ -1,2 +1,18 @@
-export {};
+import { AbstractContainerType } from "./AbstractContainerType.js";
+/**
+ * A type with zero or one values of an item type.
+ */
+export class OptionType extends AbstractContainerType {
+    kind = "OptionType";
+    constructor({ itemType, }) {
+        super({
+            comment: itemType.comment,
+            itemType,
+            label: itemType.label,
+        });
+    }
+}
+(function (OptionType) {
+    OptionType.isItemType = AbstractContainerType.isItemType;
+})(OptionType || (OptionType = {}));
 //# sourceMappingURL=OptionType.js.map

package/dist/ast/PlaceholderType.d.ts

@@ -1,7 +1,15 @@
+import { Maybe } from "purify-ts";
 /**
  * A placeholder used temporarily when a type is being resolved.
  */
-export interface PlaceholderType {
-    kind: "PlaceholderType";
+export declare class PlaceholderType {
+    static readonly instance: PlaceholderType;
+    readonly comment: Maybe<string>;
+    readonly label: Maybe<string>;
+    readonly kind = "PlaceholderType";
+    readonly name: Maybe<string>;
+    private constructor();
+    equals(_other: PlaceholderType): boolean;
+    toString(): string;
 }
 //# sourceMappingURL=PlaceholderType.d.ts.map

package/dist/ast/PlaceholderType.js

@@ -1,2 +1,19 @@
-export {};
+import { Maybe } from "purify-ts";
+/**
+ * A placeholder used temporarily when a type is being resolved.
+ */
+export class PlaceholderType {
+    static instance = new PlaceholderType();
+    comment = Maybe.empty();
+    label = Maybe.empty();
+    kind = "PlaceholderType";
+    name = Maybe.empty();
+    constructor() { }
+    equals(_other) {
+        return true;
+    }
+    toString() {
+        return `${this.kind}()`;
+    }
+}
 //# sourceMappingURL=PlaceholderType.js.map

package/dist/ast/SetType.d.ts

@@ -1,18 +1,21 @@
-import type { Maybe } from "purify-ts";
-import type { Type } from "./Type.js";
+import { AbstractCollectionType } from "./AbstractCollectionType.js";
+import type { PlaceholderType } from "./PlaceholderType.js";
 /**
  * An unordered set of items of a specific type.
  */
-export interface SetType<ItemTypeT extends Type = Type> {
-    readonly kind: "SetType";
-    readonly itemType: ItemTypeT;
+export declare class SetType<ItemTypeT extends SetType.ItemType = SetType.ItemType> extends AbstractCollectionType<ItemTypeT> {
+    readonly kind = "SetType";
     /**
      * Minimum number of items in the set.
      */
     readonly minCount: number;
-    /**
-     * The set should be mutable in generated code.
-     */
-    readonly mutable: Maybe<boolean>;
+    constructor({ itemType, minCount, ...superParameters }: {
+        minCount: number;
+    } & Pick<ConstructorParameters<typeof AbstractCollectionType<ItemTypeT>>[0], "itemType" | "mutable">);
+    equals(other: SetType<ItemTypeT>): boolean;
+}
+export declare namespace SetType {
+    type ItemType = Exclude<AbstractCollectionType.ItemType, PlaceholderType>;
+    const isItemType: typeof import("./AbstractContainerType.js").AbstractContainerType.isItemType;
 }
 //# sourceMappingURL=SetType.d.ts.map

package/dist/ast/SetType.js

@@ -1,2 +1,33 @@
-export {};
+import { AbstractCollectionType } from "./AbstractCollectionType.js";
+/**
+ * An unordered set of items of a specific type.
+ */
+export class SetType extends AbstractCollectionType {
+    kind = "SetType";
+    /**
+     * Minimum number of items in the set.
+     */
+    minCount;
+    constructor({ itemType, minCount, ...superParameters }) {
+        super({
+            ...superParameters,
+            comment: itemType.comment,
+            itemType,
+            label: itemType.label,
+        });
+        this.minCount = minCount;
+    }
+    equals(other) {
+        if (!super.equals(other)) {
+            return false;
+        }
+        if (this.minCount !== other.minCount) {
+            return false;
+        }
+        return true;
+    }
+}
+(function (SetType) {
+    SetType.isItemType = AbstractCollectionType.isItemType;
+})(SetType || (SetType = {}));
 //# sourceMappingURL=SetType.js.map

package/dist/ast/TermType.d.ts

@@ -1,19 +1,14 @@
 import type { BlankNode, Literal, NamedNode } from "@rdfjs/types";
 import type { NodeKind } from "@shaclmate/shacl-ast";
-import type { Maybe } from "purify-ts";
+import { AbstractTermType } from "./AbstractTermType.js";
 /**
- * Parent interface of term types in the ASTs (e.g., identifiers, identifiers).
- *
- * ConstantTermT is the type of sh:defaultValue, 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:defaultValue et al.
+ * Term type that is neither an IdentifierType nor a LiteralType. For example, a term type with nodeKinds = Literal | NamedNode.
  */
-export interface TermType<ConstantTermT extends Literal | NamedNode = Literal | NamedNode, _RuntimeTermT extends BlankNode | Literal | NamedNode = BlankNode | Literal | NamedNode> {
-    readonly defaultValue: Maybe<ConstantTermT>;
-    readonly hasValues: readonly ConstantTermT[];
-    readonly in_: readonly ConstantTermT[];
-    readonly kind: "IdentifierType" | "LiteralType" | "TermType";
-    readonly nodeKinds: Set<NodeKind>;
+export declare class TermType extends AbstractTermType<Literal | NamedNode, BlankNode | Literal | NamedNode> {
+    readonly kind = "TermType";
+    readonly nodeKinds: ReadonlySet<NodeKind>;
+    constructor({ nodeKinds, ...superParameters }: ConstructorParameters<typeof AbstractTermType<Literal | NamedNode, BlankNode | Literal | NamedNode>>[0] & {
+        nodeKinds: ReadonlySet<NodeKind>;
+    });
 }
 //# sourceMappingURL=TermType.d.ts.map

package/dist/ast/TermType.js

@@ -1,2 +1,16 @@
-export {};
+import { invariant } from "ts-invariant";
+import { AbstractTermType } from "./AbstractTermType.js";
+/**
+ * Term type that is neither an IdentifierType nor a LiteralType. For example, a term type with nodeKinds = Literal | NamedNode.
+ */
+export class TermType extends AbstractTermType {
+    kind = "TermType";
+    nodeKinds;
+    constructor({ nodeKinds, ...superParameters }) {
+        super(superParameters);
+        this.nodeKinds = nodeKinds;
+        invariant(this.nodeKinds.has("Literal") &&
+            (this.nodeKinds.has("BlankNode") || this.nodeKinds.has("IRI")), "should be IdentifierType or LiteralType");
+    }
+}
 //# sourceMappingURL=TermType.js.map

package/dist/ast/Type.d.ts

@@ -1,6 +1,11 @@
-import type { BlankNode, Literal, NamedNode } from "@rdfjs/types";
+import type { BlankNodeType } from "./BlankNodeType.js";
+import type { DefaultValueType } from "./DefaultValueType.js";
 import type { IdentifierType } from "./IdentifierType.js";
 import type { IntersectionType } from "./IntersectionType.js";
+import type { IriType } from "./IriType.js";
+import type { LazyObjectOptionType } from "./LazyObjectOptionType.js";
+import type { LazyObjectSetType } from "./LazyObjectSetType.js";
+import type { LazyObjectType } from "./LazyObjectType.js";
 import type { ListType } from "./ListType.js";
 import type { LiteralType } from "./LiteralType.js";
 import type { ObjectIntersectionType } from "./ObjectIntersectionType.js";
@@ -11,7 +16,8 @@ import type { PlaceholderType } from "./PlaceholderType.js";
 import type { SetType } from "./SetType.js";
 import type { TermType } from "./TermType.js";
 import type { UnionType } from "./UnionType.js";
-export type Type = IdentifierType | IntersectionType | ListType | LiteralType | ObjectIntersectionType | ObjectType | ObjectUnionType | OptionType | PlaceholderType | SetType | (Omit<TermType<Literal | NamedNode, BlankNode | Literal | NamedNode>, "kind"> & {
-    readonly kind: "TermType";
-}) | UnionType;
+export type Type = BlankNodeType | DefaultValueType | IdentifierType | IntersectionType | IriType | LazyObjectOptionType | LazyObjectSetType | LazyObjectType | ListType | LiteralType | ObjectIntersectionType | ObjectType | ObjectUnionType | OptionType | PlaceholderType | SetType | TermType | UnionType;
+export declare namespace Type {
+    function equals(left: Type, right: Type): boolean;
+}
 //# sourceMappingURL=Type.d.ts.map

package/dist/ast/Type.js

@@ -1,2 +1,48 @@
-export {};
+export var Type;
+(function (Type) {
+    function equals(left, right) {
+        if (left.kind !== right.kind) {
+            return false;
+        }
+        switch (left.kind) {
+            case "BlankNodeType":
+                return left.equals(right);
+            case "DefaultValueType":
+                return left.equals(right);
+            case "IdentifierType":
+                return left.equals(right);
+            case "IntersectionType":
+                return left.equals(right);
+            case "IriType":
+                return left.equals(right);
+            case "LiteralType":
+                return left.equals(right);
+            case "LazyObjectOptionType":
+                return left.equals(right);
+            case "LazyObjectSetType":
+                return left.equals(right);
+            case "LazyObjectType":
+                return left.equals(right);
+            case "ListType":
+                return left.equals(right);
+            case "ObjectIntersectionType":
+                return left.equals(right);
+            case "ObjectType":
+                return left.equals(right);
+            case "ObjectUnionType":
+                return left.equals(right);
+            case "OptionType":
+                return left.equals(right);
+            case "PlaceholderType":
+                return left.equals(right);
+            case "TermType":
+                return left.equals(right);
+            case "UnionType":
+                return left.equals(right);
+            case "SetType":
+                return left.equals(right);
+        }
+    }
+    Type.equals = equals;
+})(Type || (Type = {}));
 //# sourceMappingURL=Type.js.map

package/dist/ast/UnionType.d.ts

@@ -1,9 +1,13 @@
-import type { CompositeType } from "./CompositeType.js";
+import { AbstractCompoundType } from "./AbstractCompoundType.js";
 import type { Type } from "./Type.js";
 /**
  * A disjunction/union of types, corresponding to an sh:xone.
  */
-export interface UnionType extends CompositeType<Type> {
-    readonly kind: "UnionType";
+export declare class UnionType extends AbstractCompoundType<Type> {
+    readonly kind = "UnionType";
+    readonly memberDiscriminantValues: readonly string[];
+    constructor({ memberDiscriminantValues, ...superParameters }: {
+        memberDiscriminantValues: readonly string[];
+    } & ConstructorParameters<typeof AbstractCompoundType<Type>>[0]);
 }
 //# sourceMappingURL=UnionType.d.ts.map

package/dist/ast/UnionType.js

@@ -1,2 +1,13 @@
-export {};
+import { AbstractCompoundType } from "./AbstractCompoundType.js";
+/**
+ * A disjunction/union of types, corresponding to an sh:xone.
+ */
+export class UnionType extends AbstractCompoundType {
+    kind = "UnionType";
+    memberDiscriminantValues;
+    constructor({ memberDiscriminantValues, ...superParameters }) {
+        super(superParameters);
+        this.memberDiscriminantValues = memberDiscriminantValues;
+    }
+}
 //# sourceMappingURL=UnionType.js.map

package/dist/ast/equals.d.ts

@@ -0,0 +1,12 @@
+import type { Term } from "@rdfjs/types";
+import type { Maybe } from "purify-ts";
+type EqualsFunction<T> = (left: T, right: T) => boolean;
+export declare function arrayEquals<T>(elementEquals: EqualsFunction<T>): EqualsFunction<readonly T[]>;
+export declare function dateEquals(left: Date, right: Date): boolean;
+export declare function maybeEquals<T>(valueEquals: EqualsFunction<T>): EqualsFunction<Maybe<T>>;
+export declare function recordEquals<KeyT extends keyof any, ValueT>(valueEquals: EqualsFunction<ValueT>): EqualsFunction<Record<KeyT, ValueT>>;
+export declare function setEquals<T>(elementEquals: EqualsFunction<T>): EqualsFunction<ReadonlySet<T>>;
+export declare function strictEquals<T>(left: T, right: T): boolean;
+export declare function termEquals(left: Term, right: Term): boolean;
+export {};
+//# sourceMappingURL=equals.d.ts.map

package/dist/ast/equals.js

@@ -0,0 +1,65 @@
+export function arrayEquals(elementEquals) {
+    return (left, right) => {
+        if (left.length !== right.length) {
+            return false;
+        }
+        for (let i = 0; i < left.length; i++) {
+            if (!elementEquals(left[i], right[i])) {
+                return false;
+            }
+        }
+        return true;
+    };
+}
+export function dateEquals(left, right) {
+    return left.getTime() === right.getTime();
+}
+export function maybeEquals(valueEquals) {
+    return (left, right) => {
+        if (left.isJust()) {
+            if (right.isJust()) {
+                return valueEquals(left.unsafeCoerce(), right.unsafeCoerce());
+            }
+            return false;
+        }
+        if (right.isJust()) {
+            return false;
+        }
+        return true;
+    };
+}
+export function recordEquals(valueEquals) {
+    return (left, right) => {
+        const leftKeys = Object.keys(left);
+        const rightKeys = Object.keys(right);
+        if (leftKeys.length !== rightKeys.length) {
+            return false;
+        }
+        for (const leftKey of leftKeys) {
+            const leftValue = left[leftKey];
+            const rightValue = right[leftKey];
+            if (rightValue === undefined) {
+                return false;
+            }
+            if (!valueEquals(leftValue, rightValue)) {
+                return false;
+            }
+        }
+        return true;
+    };
+}
+export function setEquals(elementEquals) {
+    return (left, right) => {
+        if (left.size !== right.size) {
+            return false;
+        }
+        return arrayEquals(elementEquals)([...left], [...right]);
+    };
+}
+export function strictEquals(left, right) {
+    return left === right;
+}
+export function termEquals(left, right) {
+    return left.equals(right);
+}
+//# sourceMappingURL=equals.js.map

package/dist/ast/index.d.ts

@@ -1,14 +1,22 @@
 export * from "./Ast.js";
+export * from "./BlankNodeType.js";
+export * from "./Curie.js";
+export * from "./DefaultValueType.js";
 export * from "./IdentifierType.js";
 export * from "./IntersectionType.js";
+export * from "./IriType.js";
+export * from "./LazyObjectOptionType.js";
+export * from "./LazyObjectSetType.js";
+export * from "./LazyObjectType.js";
 export * from "./ListType.js";
 export * from "./LiteralType.js";
-export * from "./Name.js";
 export * from "./ObjectIntersectionType.js";
 export * from "./ObjectType.js";
 export * from "./ObjectUnionType.js";
+export * from "./OptionType.js";
+export * from "./PlaceholderType.js";
 export * from "./SetType.js";
-export * from "./UnionType.js";
 export * from "./TermType.js";
 export * from "./Type.js";
+export * from "./UnionType.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/ast/index.js

@@ -1,14 +1,22 @@
 export * from "./Ast.js";
+export * from "./BlankNodeType.js";
+export * from "./Curie.js";
+export * from "./DefaultValueType.js";
 export * from "./IdentifierType.js";
 export * from "./IntersectionType.js";
+export * from "./IriType.js";
+export * from "./LazyObjectOptionType.js";
+export * from "./LazyObjectSetType.js";
+export * from "./LazyObjectType.js";
 export * from "./ListType.js";
 export * from "./LiteralType.js";
-export * from "./Name.js";
 export * from "./ObjectIntersectionType.js";
 export * from "./ObjectType.js";
 export * from "./ObjectUnionType.js";
+export * from "./OptionType.js";
+export * from "./PlaceholderType.js";
 export * from "./SetType.js";
-export * from "./UnionType.js";
 export * from "./TermType.js";
 export * from "./Type.js";
+export * from "./UnionType.js";
 //# sourceMappingURL=index.js.map

package/dist/generators/json/AstJsonGenerator.js

@@ -1,26 +1,4 @@
-function nameToJson(name) {
-    return {
-        identifier: {
-            curie: name.identifier.termType === "NamedNode"
-                ? name.identifier.curie.map((curie) => curie.toString()).extract()
-                : undefined,
-            termType: name.identifier.termType,
-            uniqueLocalPart: name.identifier.termType === "NamedNode"
-                ? name.identifier.uniqueLocalPart().extract()
-                : undefined,
-            value: name.identifier.value,
-        },
-        label: name.label.extract(),
-        propertyPath: name.propertyPath.map((propertyPath) => ({
-            curie: propertyPath.curie.map((curie) => curie.toString()).extract(),
-            uniqueLocalPart: propertyPath.uniqueLocalPart().extract(),
-            termType: propertyPath.termType,
-            value: propertyPath.value,
-        })),
-        shName: name.shName.extract(),
-        shaclmateName: name.shaclmateName.extract(),
-    };
-}
+import { Resource } from "rdfjs-resource";
 function termToJson(term) {
     switch (term.termType) {
         case "BlankNode":
@@ -39,31 +17,51 @@ function termToJson(term) {
     }
 }
 function typeToJson(type) {
+    const common = {
+        kind: type.kind,
+        comment: type.comment.extract(),
+        label: type.label.extract(),
+    };
     switch (type.kind) {
+        case "BlankNodeType":
         case "IdentifierType":
+        case "IriType":
             return {
-                hasValue: type.hasValues.map(termToJson),
-                kind: type.kind,
+                ...common,
+                hasValue: type.hasValues.length > 0
+                    ? type.hasValues.map(termToJson)
+                    : undefined,
                 nodeKinds: [...type.nodeKinds],
             };
         case "IntersectionType":
         case "UnionType":
             return {
-                kind: type.kind,
-                types: type.memberTypes.map((type) => typeToJson(type)),
+                ...common,
+                memberDiscriminantValues: type.kind === "UnionType" ? type.memberDiscriminantValues : undefined,
+                memberTypes: type.memberTypes.map((type) => typeToJson(type)),
+            };
+        case "LazyObjectOptionType":
+        case "LazyObjectSetType":
+        case "LazyObjectType":
+            return {
+                ...common,
+                partialType: typeToJson(type.partialType),
+                resolveType: typeToJson(type.resolveType),
             };
         case "ListType": {
             return {
+                ...common,
                 itemType: typeToJson(type.itemType),
-                kind: type.kind,
-                mutable: type.mutable.extract(),
+                mutable: type.mutable,
             };
         }
         case "LiteralType": {
             return {
+                ...common,
                 datatype: type.datatype.extract(),
-                hasValue: type.hasValues.map(termToJson),
-                kind: type.kind,
+                hasValue: type.hasValues.length > 0
+                    ? type.hasValues.map(termToJson)
+                    : undefined,
                 maxExclusive: type.maxExclusive.map(termToJson).extract(),
                 maxInclusive: type.maxInclusive.map(termToJson).extract(),
                 minExclusive: type.minExclusive.map(termToJson).extract(),
@@ -73,42 +71,43 @@ function typeToJson(type) {
         case "ObjectIntersectionType":
         case "ObjectUnionType":
             return {
-                kind: type.kind,
-                name: nameToJson(type.name),
-                types: type.memberTypes.map((type) => typeToJson(type)),
+                ...common,
+                name: type.name.extract(),
+                memberTypes: type.memberTypes.map((type) => typeToJson(type)),
+                shapeIdentifier: Resource.Identifier.toString(type.shapeIdentifier),
             };
         case "ObjectType":
             return {
+                ...common,
+                name: type.name.extract(),
+                shapeIdentifier: Resource.Identifier.toString(type.shapeIdentifier),
                 fromRdfType: type.fromRdfType.map(termToJson).extract(),
-                kind: type.kind,
-                name: nameToJson(type.name),
                 parentObjectTypes: type.parentObjectTypes.length > 0
-                    ? type.parentObjectTypes.map((type) => nameToJson(type.name))
-                    : undefined,
-                identifierIn: type.identifierIn.length > 0
-                    ? type.identifierIn.map(termToJson)
+                    ? type.parentObjectTypes.map((type) => Resource.Identifier.toString(type.shapeIdentifier))
                     : undefined,
-                identifierNodeKinds: [...type.identifierNodeKinds],
                 identifierMintingStrategy: type.identifierMintingStrategy.extract(),
+                identifierType: typeToJson(type.identifierType),
+                synthetic: type.synthetic ? true : undefined,
                 toRdfTypes: type.toRdfTypes.length > 0
                     ? type.toRdfTypes.map(termToJson)
                     : undefined,
             };
+        case "DefaultValueType":
         case "OptionType":
             return {
+                ...common,
                 itemType: typeToJson(type.itemType),
-                kind: type.kind,
             };
         case "PlaceholderType":
             throw new Error(type.kind);
         case "SetType":
             return {
+                ...common,
                 itemType: typeToJson(type.itemType),
-                kind: type.kind,
             };
         case "TermType":
             return {
-                kind: type.kind,
+                ...common,
             };
     }
 }
@@ -117,17 +116,22 @@ export class AstJsonGenerator {
         return JSON.stringify({
             objectTypes: ast.objectTypes.map((objectType) => ({
                 kind: objectType.kind,
-                name: nameToJson(objectType.name),
+                comment: objectType.comment.extract(),
+                identifierMintingStrategy: objectType.identifierMintingStrategy.extract(),
+                identifierType: typeToJson(objectType.identifierType),
+                label: objectType.label.extract(),
+                name: objectType.name.extract(),
+                shapeIdentifier: Resource.Identifier.toString(objectType.shapeIdentifier),
                 properties: objectType.properties.map((property) => ({
                     comment: property.comment.extract(),
                     description: property.description.extract(),
                     label: property.label.extract(),
-                    mutable: property.mutable.extract(),
-                    name: nameToJson(property.name),
+                    mutable: property.mutable,
+                    name: property.name.extract(),
                     order: property.order,
-                    path: property.path.iri.value,
+                    path: property.path,
                     recursive: property.recursive ? true : undefined,
-                    stubType: property.stubType.map(typeToJson).extract(),
+                    shapeIdentifier: Resource.Identifier.toString(property.shapeIdentifier),
                     type: typeToJson(property.type),
                     visibility: property.visibility,
                 })),

package/dist/generators/ts/AbstractCollectionType.d.ts

@@ -0,0 +1,47 @@
+import { Maybe, NonEmptyList } from "purify-ts";
+import { AbstractContainerType } from "./AbstractContainerType.js";
+import { type Code } from "./ts-poet-wrapper.js";
+/**
+ * Abstract base class for ListType and SetType.
+ */
+export declare abstract class AbstractCollectionType<ItemTypeT extends AbstractCollectionType.ItemType> extends AbstractContainerType<ItemTypeT> {
+    protected readonly _mutable: boolean;
+    protected readonly minCount: number;
+    readonly discriminantProperty: Maybe<AbstractContainerType.DiscriminantProperty>;
+    readonly graphqlArgs: AbstractContainerType<ItemTypeT>["graphqlArgs"];
+    readonly typeofs: NonEmptyList<"object">;
+    constructor({ minCount, mutable, ...superParameters }: {
+        minCount: number;
+        mutable: boolean;
+    } & ConstructorParameters<typeof AbstractContainerType<ItemTypeT>>[0]);
+    get conversions(): readonly AbstractContainerType.Conversion[];
+    get equalsFunction(): Code;
+    get filterFunction(): Code;
+    get filterType(): Code;
+    get graphqlType(): AbstractContainerType.GraphqlType;
+    get mutable(): boolean;
+    get name(): Code;
+    get schemaType(): Code;
+    protected get schemaObject(): {
+        minCount: number | undefined;
+        item: Code;
+        kind: Code;
+    };
+    fromJsonExpression({ variables, }: Parameters<AbstractContainerType<ItemTypeT>["fromJsonExpression"]>[0]): Code;
+    graphqlResolveExpression({ variables, }: Parameters<AbstractContainerType<ItemTypeT>["graphqlResolveExpression"]>[0]): Code;
+    hashStatements({ depth, variables, }: Parameters<AbstractContainerType<ItemTypeT>["hashStatements"]>[0]): readonly Code[];
+    jsonUiSchemaElement(parameters: Parameters<AbstractContainerType<ItemTypeT>["jsonUiSchemaElement"]>[0]): Maybe<Code>;
+    jsonZodSchema(parameters: Parameters<AbstractContainerType<ItemTypeT>["jsonZodSchema"]>[0]): Code;
+    toJsonExpression({ variables, }: Parameters<AbstractContainerType<ItemTypeT>["toJsonExpression"]>[0]): Code;
+}
+export declare namespace AbstractCollectionType {
+    type Conversion = AbstractContainerType.Conversion;
+    type DiscriminantProperty = AbstractContainerType.DiscriminantProperty;
+    const GraphqlType: typeof import("./AbstractType.js").AbstractType.GraphqlType;
+    type GraphqlType = AbstractContainerType.GraphqlType;
+    const isItemType: typeof AbstractContainerType.isItemType;
+    type ItemType = AbstractContainerType.ItemType;
+    const JsonType: typeof import("./AbstractType.js").AbstractType.JsonType;
+    type JsonType = AbstractContainerType.JsonType;
+}
+//# sourceMappingURL=AbstractCollectionType.d.ts.map