@shaclmate/compiler 2.0.23 → 2.0.24

package/dist/generators/ts/TypeFactory.js

@@ -24,9 +24,69 @@ import { UnionType } from "./UnionType.js";
 import { syntheticNamePrefix } from "./syntheticNamePrefix.js";
 import { tsName } from "./tsName.js";
 export class TypeFactory {
+    cachedBooleanType = new BooleanType({
+        defaultValue: Maybe.empty(),
+        hasValues: [],
+        in_: [],
+        languageIn: [],
+        primitiveDefaultValue: Maybe.empty(),
+        primitiveIn: [],
+    });
+    cachedDateType = new DateType({
+        defaultValue: Maybe.empty(),
+        hasValues: [],
+        in_: [],
+        languageIn: [],
+        primitiveDefaultValue: Maybe.empty(),
+        primitiveIn: [],
+    });
+    cachedDateTimeType = new DateTimeType({
+        defaultValue: Maybe.empty(),
+        hasValues: [],
+        in_: [],
+        languageIn: [],
+        primitiveDefaultValue: Maybe.empty(),
+        primitiveIn: [],
+    });
+    cachedFloatType = new FloatType({
+        defaultValue: Maybe.empty(),
+        hasValues: [],
+        in_: [],
+        languageIn: [],
+        primitiveDefaultValue: Maybe.empty(),
+        primitiveIn: [],
+    });
+    cachedIdentifierType = new IdentifierType({
+        defaultValue: Maybe.empty(),
+        hasValues: [],
+        in_: [],
+        nodeKinds: new Set(["BlankNode", "NamedNode"]),
+    });
+    cachedIntType = new IntType({
+        defaultValue: Maybe.empty(),
+        hasValues: [],
+        in_: [],
+        languageIn: [],
+        primitiveDefaultValue: Maybe.empty(),
+        primitiveIn: [],
+    });
+    cachedNamedIdentifierType = new IdentifierType({
+        defaultValue: Maybe.empty(),
+        hasValues: [],
+        in_: [],
+        nodeKinds: new Set(["NamedNode"]),
+    });
     cachedObjectTypePropertiesByIdentifier = new TermMap();
     cachedObjectTypesByIdentifier = new TermMap();
     cachedObjectUnionTypesByIdentifier = new TermMap();
+    cachedStringType = new StringType({
+        defaultValue: Maybe.empty(),
+        hasValues: [],
+        in_: [],
+        languageIn: [],
+        primitiveDefaultValue: Maybe.empty(),
+        primitiveIn: [],
+    });
     createObjectTypeFromAstType(astType) {
         {
             const cachedObjectType = this.cachedObjectTypesByIdentifier.get(astType.name.identifier);
@@ -106,21 +166,14 @@ export class TypeFactory {
                         own: !astType.ancestorObjectTypes.some(objectTypeNeedsIdentifierPrefixProperty),
                         name: `${syntheticNamePrefix}identifierPrefix`,
                         objectType,
-                        type: new StringType({
-                            defaultValue: Maybe.empty(),
-                            hasValues: [],
-                            in_: [],
-                            languageIn: [],
-                            primitiveDefaultValue: Maybe.empty(),
-                            primitiveIn: [],
-                        }),
+                        type: this.cachedStringType,
                         visibility: "protected",
                     }));
                 }
                 // Every ObjectType has an identifier property. Some are abstract.
                 properties.splice(0, 0, new ObjectType.IdentifierProperty({
                     abstract: astType.abstract,
-                    classGetAccessorScope: (() => {
+                    getAccessorScope: (() => {
                         if (astType.abstract) {
                             return Maybe.empty();
                         }
@@ -130,7 +183,12 @@ export class TypeFactory {
                         }
                         return Maybe.empty();
                     })(),
-                    classPropertyDeclarationVisibility: (() => {
+                    identifierMintingStrategy: astType.identifierMintingStrategy,
+                    identifierPrefixPropertyName: `${syntheticNamePrefix}identifierPrefix`,
+                    name: `${syntheticNamePrefix}identifier`,
+                    objectType,
+                    override: astType.parentObjectTypes.length > 0,
+                    propertyDeclarationVisibility: (() => {
                         if (astType.abstract) {
                             // If the type is abstract, don't declare an identifier property.
                             return Maybe.empty();
@@ -145,11 +203,6 @@ export class TypeFactory {
                         }
                         return Maybe.of("private");
                     })(),
-                    identifierMintingStrategy: astType.identifierMintingStrategy,
-                    identifierPrefixPropertyName: `${syntheticNamePrefix}identifierPrefix`,
-                    name: `${syntheticNamePrefix}identifier`,
-                    objectType,
-                    override: astType.parentObjectTypes.length > 0,
                     type: identifierType,
                     typeAlias: `${staticModuleName}.${syntheticNamePrefix}Identifier`,
                     visibility: "public",
@@ -168,6 +221,17 @@ export class TypeFactory {
     createTypeFromAstType(astType) {
         switch (astType.kind) {
             case "IdentifierType":
+                if (astType.defaultValue.isNothing() &&
+                    astType.hasValues.length === 0 &&
+                    astType.in_.length === 0) {
+                    if (astType.nodeKinds.size === 2) {
+                        return this.cachedIdentifierType;
+                    }
+                    if (astType.nodeKinds.size === 1 &&
+                        astType.nodeKinds.has("NamedNode")) {
+                        return this.cachedNamedIdentifierType;
+                    }
+                }
                 return new IdentifierType({
                     defaultValue: astType.defaultValue,
                     hasValues: astType.hasValues,
@@ -201,6 +265,11 @@ export class TypeFactory {
                 if (datatypes.size === 1) {
                     const datatype = [...datatypes][0];
                     if (datatype.equals(xsd.boolean)) {
+                        if (astType.defaultValue.isNothing() &&
+                            astType.hasValues.length === 0 &&
+                            astType.in_.length === 0) {
+                            return this.cachedBooleanType;
+                        }
                         return new BooleanType({
                             defaultValue: astType.defaultValue,
                             hasValues: astType.hasValues,
@@ -215,6 +284,13 @@ export class TypeFactory {
                         });
                     }
                     if (datatype.equals(xsd.date) || datatype.equals(xsd.dateTime)) {
+                        if (astType.defaultValue.isNothing() &&
+                            astType.hasValues.length === 0 &&
+                            astType.in_.length === 0) {
+                            return datatype.equals(xsd.date)
+                                ? this.cachedDateType
+                                : this.cachedDateTimeType;
+                        }
                         return new (datatype.equals(xsd.date) ? DateType : DateTimeType)({
                             defaultValue: astType.defaultValue,
                             hasValues: astType.hasValues,
@@ -231,6 +307,13 @@ export class TypeFactory {
                     for (const [floatOrInt, numberDatatypes_] of Object.entries(numberDatatypes)) {
                         for (const numberDatatype of numberDatatypes_) {
                             if (datatype.equals(numberDatatype)) {
+                                if (astType.defaultValue.isNothing() &&
+                                    astType.hasValues.length === 0 &&
+                                    astType.in_.length === 0) {
+                                    return floatOrInt === "float"
+                                        ? this.cachedFloatType
+                                        : this.cachedIntType;
+                                }
                                 return new (floatOrInt === "float" ? FloatType : IntType)({
                                     defaultValue: astType.defaultValue,
                                     hasValues: astType.hasValues,
@@ -247,6 +330,11 @@ export class TypeFactory {
                         }
                     }
                     if (datatype.equals(xsd.anyURI) || datatype.equals(xsd.string)) {
+                        if (astType.defaultValue.isNothing() &&
+                            astType.hasValues.length === 0 &&
+                            astType.in_.length === 0) {
+                            return this.cachedStringType;
+                        }
                         return new StringType({
                             defaultValue: astType.defaultValue,
                             hasValues: astType.hasValues,
@@ -329,6 +417,14 @@ export class TypeFactory {
                     stubType,
                 });
             }
+            else if (resolvedType instanceof ObjectType ||
+                resolvedType instanceof ObjectUnionType) {
+                invariant(stubType instanceof ObjectType || stubType instanceof ObjectUnionType, `lazy property ${name} on ${objectType.name} has ${stubType.kind} stubs`);
+                lazyType = new ObjectType.LazyShaclProperty.RequiredObjectType({
+                    resolvedType: resolvedType,
+                    stubType: stubType,
+                });
+            }
             else if (resolvedType instanceof SetType) {
                 invariant(resolvedType.itemType instanceof ObjectType ||
                     resolvedType.itemType instanceof ObjectUnionType, `lazy property ${name} on ${objectType.name} has ${resolvedType.kind} ${resolvedType.itemType.kind} items`);
@@ -339,13 +435,7 @@ export class TypeFactory {
                 });
             }
             else {
-                invariant(resolvedType instanceof ObjectType ||
-                    resolvedType instanceof ObjectUnionType, `lazy property ${name} on ${objectType.name} has ${resolvedType.kind}`);
-                invariant(stubType instanceof ObjectType || stubType instanceof ObjectUnionType, `lazy property ${name} on ${objectType.name} has ${stubType.kind} stubs`);
-                lazyType = new ObjectType.LazyShaclProperty.RequiredObjectType({
-                    resolvedType,
-                    stubType,
-                });
+                throw new Error(`lazy property ${name} on ${objectType.name} has ${resolvedType.kind}`);
             }
             property = new ObjectType.LazyShaclProperty({
                 comment: astObjectTypeProperty.comment,

package/dist/generators/ts/UnionType.js

@@ -257,7 +257,7 @@ ${this.memberTypes
             if (this._discriminator.kind === "syntheticProperty") {
                 typeExpression = `${typeExpression}.map(value => ({ ${this._discriminator.name}: "${memberType.discriminatorValues[0]}" as const, value }) as (${this.name}))`;
             }
-            typeExpression = `(${typeExpression} as purify.Either<Error, ${this.name}>)`;
+            typeExpression = `(${typeExpression} as purify.Either<Error, rdfjsResource.Resource.Values<${this.name}>>)`;
             return expression.length > 0
                 ? `${expression}.altLazy(() => ${typeExpression})`
                 : typeExpression;

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

@@ -17,9 +17,10 @@ export class EagerShaclProperty extends ShaclProperty {
     }
     get graphqlField() {
         return Maybe.of({
-            description: this.comment.map(JSON.stringify).extract(),
+            args: Maybe.empty(),
+            description: this.comment.map(JSON.stringify),
             name: this.name,
-            resolve: `(source) => ${this.type.graphqlResolveExpression({ variables: { value: `source.${this.name}` } })}`,
+            resolve: `(source, _args) => ${this.type.graphqlResolveExpression({ variables: { args: "_args", value: `source.${this.name}` } })}`,
             type: this.type.graphqlName.toString(),
         });
     }

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

@@ -7,7 +7,6 @@ import { Property } from "./Property.js";
 export declare class IdentifierPrefixProperty extends Property<StringType> {
     private readonly own;
     readonly declarationImports: readonly Import[];
-    readonly equalsFunction = "$strictEquals";
     readonly graphqlField: Property<StringType>["graphqlField"];
     readonly propertySignature: Maybe<OptionalKind<PropertySignatureStructure>>;
     readonly jsonPropertySignature: Maybe<OptionalKind<PropertySignatureStructure>>;
@@ -18,6 +17,7 @@ export declare class IdentifierPrefixProperty extends Property<StringType> {
         type: StringType;
     } & ConstructorParameters<typeof Property>[0]);
     get constructorParametersPropertySignature(): Maybe<OptionalKind<PropertySignatureStructure>>;
+    get equalsFunction(): Maybe<string>;
     constructorStatements({ variables, }: Parameters<Property<IdentifierType>["constructorStatements"]>[0]): readonly string[];
     fromJsonStatements(): readonly string[];
     fromRdfStatements(): readonly string[];

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

@@ -1,13 +1,19 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
 import { Maybe } from "purify-ts";
 import { invariant } from "ts-invariant";
 import { Scope, } from "ts-morph";
+import { Memoize } from "typescript-memoize";
 import { SnippetDeclarations } from "../SnippetDeclarations.js";
 import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 import { Property } from "./Property.js";
 export class IdentifierPrefixProperty extends Property {
     own;
     declarationImports = [];
-    equalsFunction = `${syntheticNamePrefix}strictEquals`;
     graphqlField = Maybe.empty();
     propertySignature = Maybe.empty();
     jsonPropertySignature = Maybe.empty();
@@ -26,6 +32,11 @@ export class IdentifierPrefixProperty extends Property {
             type: this.type.name,
         });
     }
+    get equalsFunction() {
+        return this.objectType.declarationType === "class"
+            ? Maybe.of(`${syntheticNamePrefix}strictEquals`)
+            : Maybe.empty();
+    }
     constructorStatements({ variables, }) {
         switch (this.objectType.declarationType) {
             case "class":
@@ -94,4 +105,7 @@ export class IdentifierPrefixProperty extends Property {
         return [];
     }
 }
+__decorate([
+    Memoize()
+], IdentifierPrefixProperty.prototype, "equalsFunction", null);
 //# sourceMappingURL=IdentifierPrefixProperty.js.map

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

@@ -5,20 +5,20 @@ import type { IdentifierType } from "../IdentifierType.js";
 import { Import } from "../Import.js";
 import { Property } from "./Property.js";
 export declare class IdentifierProperty extends Property<IdentifierType> {
-    private readonly classGetAccessorScope;
-    private readonly classPropertyDeclarationVisibility;
+    private readonly getAccessorScope;
     private readonly identifierMintingStrategy;
     private readonly identifierPrefixPropertyName;
     private readonly override;
+    private readonly propertyDeclarationVisibility;
     private readonly typeAlias;
     readonly abstract: boolean;
-    readonly equalsFunction = "$booleanEquals";
+    readonly equalsFunction: Maybe<string>;
     readonly mutable = false;
     readonly recursive = false;
-    constructor({ abstract, classGetAccessorScope, classPropertyDeclarationVisibility, identifierMintingStrategy, identifierPrefixPropertyName, override, typeAlias, ...superParameters }: {
+    constructor({ abstract, getAccessorScope, identifierMintingStrategy, identifierPrefixPropertyName, override, propertyDeclarationVisibility, typeAlias, ...superParameters }: {
         abstract: boolean;
-        classGetAccessorScope: Maybe<Scope>;
-        classPropertyDeclarationVisibility: Maybe<PropertyVisibility>;
+        getAccessorScope: Maybe<Scope>;
+        propertyDeclarationVisibility: Maybe<PropertyVisibility>;
         identifierMintingStrategy: Maybe<IdentifierMintingStrategy>;
         identifierPrefixPropertyName: string;
         override: boolean;

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

@@ -1,29 +1,29 @@
 import { rdf } from "@tpluscode/rdf-ns-builders";
 import { Maybe } from "purify-ts";
 import { invariant } from "ts-invariant";
+import { logger } from "../../../logger.js";
 import { Import } from "../Import.js";
 import { SnippetDeclarations } from "../SnippetDeclarations.js";
 import { rdfjsTermExpression } from "../rdfjsTermExpression.js";
 import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
 import { Property } from "./Property.js";
 export class IdentifierProperty extends Property {
-    classGetAccessorScope;
-    classPropertyDeclarationVisibility;
+    getAccessorScope;
     identifierMintingStrategy;
     identifierPrefixPropertyName;
     override;
+    propertyDeclarationVisibility;
     typeAlias;
     abstract;
-    equalsFunction = `${syntheticNamePrefix}booleanEquals`;
+    equalsFunction = Maybe.of(`${syntheticNamePrefix}booleanEquals`);
     mutable = false;
     recursive = false;
-    constructor({ abstract, classGetAccessorScope, classPropertyDeclarationVisibility, identifierMintingStrategy, identifierPrefixPropertyName, override, typeAlias, ...superParameters }) {
+    constructor({ abstract, getAccessorScope, identifierMintingStrategy, identifierPrefixPropertyName, override, propertyDeclarationVisibility, typeAlias, ...superParameters }) {
         super(superParameters);
         invariant(this.visibility === "public");
         this.abstract = abstract;
-        this.classGetAccessorScope = classGetAccessorScope;
-        this.classPropertyDeclarationVisibility =
-            classPropertyDeclarationVisibility;
+        this.getAccessorScope = getAccessorScope;
+        this.propertyDeclarationVisibility = propertyDeclarationVisibility;
         this.identifierMintingStrategy = identifierMintingStrategy;
         this.identifierPrefixPropertyName = identifierPrefixPropertyName;
         this.override = override;
@@ -39,9 +39,21 @@ export class IdentifierProperty extends Property {
                 typeNames.add(conversion.sourceTypeName);
             }
         }
+        let hasQuestionToken;
+        switch (this.objectType.declarationType) {
+            case "class":
+                hasQuestionToken = this.identifierMintingStrategy.isJust();
+                break;
+            case "interface": {
+                const identifierMintingStrategy = this.identifierMintingStrategy.extract();
+                hasQuestionToken =
+                    typeof identifierMintingStrategy !== "undefined" &&
+                        identifierMintingStrategy !== "sha256";
+                break;
+            }
+        }
         return Maybe.of({
-            hasQuestionToken: this.objectType.declarationType === "class" &&
-                this.identifierMintingStrategy.isJust(),
+            hasQuestionToken,
             isReadonly: true,
             name: this.name,
             type: [...typeNames].sort().join(" | "),
@@ -49,26 +61,23 @@ export class IdentifierProperty extends Property {
     }
     get declarationImports() {
         const imports = this.type.useImports().concat();
-        if (this.objectType.features.has("hash") &&
-            this.objectType.declarationType === "class") {
-            this.identifierMintingStrategy.ifJust((identifierMintingStrategy) => {
-                switch (identifierMintingStrategy) {
-                    case "sha256":
-                        imports.push(Import.SHA256);
-                        break;
-                    case "uuidv4":
-                        imports.push(Import.UUID);
-                        break;
-                }
-            });
-        }
+        this.identifierMintingStrategy.ifJust((identifierMintingStrategy) => {
+            switch (identifierMintingStrategy) {
+                case "sha256":
+                    imports.push(Import.SHA256);
+                    break;
+                case "uuidv4":
+                    imports.push(Import.UUID);
+                    break;
+            }
+        });
         return imports;
     }
     get getAccessorDeclaration() {
-        if (this.classGetAccessorScope.isNothing()) {
+        if (this.getAccessorScope.isNothing()) {
             return Maybe.empty();
         }
-        invariant(this.classGetAccessorScope.unsafeCoerce() === "public");
+        invariant(this.getAccessorScope.unsafeCoerce() === "public");
         if (this.identifierMintingStrategy.isJust()) {
             let memoizeMintedIdentifier;
             let mintIdentifier;
@@ -109,6 +118,8 @@ export class IdentifierProperty extends Property {
     get graphqlField() {
         invariant(this.name.startsWith(syntheticNamePrefix));
         return Maybe.of({
+            args: Maybe.empty(),
+            description: Maybe.empty(),
             name: `_${this.name.substring(syntheticNamePrefix.length)}`,
             resolve: `(source) => ${this.typeAlias}.toString(source.${this.name})`,
             type: this.type.graphqlName.toString(),
@@ -153,9 +164,28 @@ export class IdentifierProperty extends Property {
             invariant(conversion.sourceTypeName !== "undefined");
             conversionBranches.push(`if (${conversion.sourceTypeCheckExpression(variables.parameter)}) { ${lhs} = ${conversion.conversionExpression(variables.parameter)}; }`);
         }
-        if (lhs.startsWith("this._")) {
-            conversionBranches.push(`if (typeof ${variables.parameter} === "undefined") { }`);
-        }
+        this.identifierMintingStrategy.ifJust((identifierMintingStrategy) => {
+            switch (this.objectType.declarationType) {
+                case "class":
+                    conversionBranches.push(`if (typeof ${variables.parameter} === "undefined") { }`);
+                    break;
+                case "interface": {
+                    let mintIdentifier;
+                    switch (identifierMintingStrategy) {
+                        case "blankNode":
+                            mintIdentifier = "dataFactory.blankNode()";
+                            break;
+                        case "sha256":
+                            logger.warn("minting %s identifiers with %s is unsupported", this.objectType.declarationType, identifierMintingStrategy);
+                            return;
+                        case "uuidv4":
+                            mintIdentifier = `dataFactory.namedNode(\`\${${variables.parameters}.${this.identifierPrefixPropertyName} ?? "urn:shaclmate:${this.objectType.discriminatorValue}:"}\${uuid.v4()}\`)`;
+                            break;
+                    }
+                    conversionBranches.push(`if (typeof ${variables.parameter} === "undefined") { ${lhs} = ${mintIdentifier}; }`);
+                }
+            }
+        });
         // We shouldn't need this else, since the parameter now has the never type, but have to add it to appease the TypeScript compiler
         conversionBranches.push(`{ ${lhs} = (${variables.parameter}) satisfies never;\n }`);
         statements.push(conversionBranches.join(" else "));
@@ -217,7 +247,7 @@ export class IdentifierProperty extends Property {
             });
         }
         // See note in TypeFactory re: the logic of whether to declare the identifier in the class or not.
-        if (!this.classPropertyDeclarationVisibility.isJust()) {
+        if (!this.propertyDeclarationVisibility.isJust()) {
             return Maybe.empty();
         }
         if (this.identifierMintingStrategy.isJust()) {
@@ -225,7 +255,7 @@ export class IdentifierProperty extends Property {
             return Maybe.of({
                 hasQuestionToken: true,
                 name: `_${this.name}`,
-                scope: this.classPropertyDeclarationVisibility
+                scope: this.propertyDeclarationVisibility
                     .map(Property.visibilityToScope)
                     .unsafeCoerce(),
                 type: `${this.typeAlias}`,

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

@@ -18,6 +18,9 @@ export declare namespace LazyShaclProperty {
         readonly discriminatorProperty: _Type["discriminatorProperty"];
         readonly mutable = false;
         readonly typeof = "object";
+        abstract readonly graphqlArgs: Maybe<Record<string, {
+            type: string;
+        }>>;
         protected readonly resolvedType: ResolvedTypeT;
         protected readonly runtimeClass: {
             readonly name: string;
@@ -34,7 +37,6 @@ export declare namespace LazyShaclProperty {
         get conversions(): readonly _Type.Conversion[];
         get equalsFunction(): string;
         get graphqlName(): _Type.GraphqlName;
-        graphqlResolveExpression({ variables, }: Parameters<_Type["graphqlResolveExpression"]>[0]): string;
         hashStatements({ depth, variables, }: Parameters<_Type["hashStatements"]>[0]): readonly string[];
         get jsonName(): _Type.JsonName;
         jsonUiSchemaElement(parameters: Parameters<_Type["jsonUiSchemaElement"]>[0]): Maybe<string>;
@@ -61,9 +63,20 @@ export declare namespace LazyShaclProperty {
         get conversions(): readonly _Type.Conversion[];
         fromJsonExpression(parameters: Parameters<_Type["fromJsonExpression"]>[0]): string;
         fromRdfExpression(parameters: Parameters<_Type["fromRdfExpression"]>[0]): string;
+        get graphqlArgs(): Maybe<{
+            limit: {
+                type: string;
+            };
+            offset: {
+                type: string;
+            };
+        }>;
+        graphqlResolveExpression({ variables, }: Parameters<_Type["graphqlResolveExpression"]>[0]): string;
     }
     abstract class SingleObjectType<ResolvedTypeT extends Exclude<Type.ResolvedTypeConstraint, SetType<ObjectType | ObjectUnionType>>, StubTypeT extends Exclude<Type.StubTypeConstraint, SetType<ObjectType | ObjectUnionType>>> extends Type<ResolvedTypeT, StubTypeT> {
         fromJsonExpression(parameters: Parameters<_Type["fromJsonExpression"]>[0]): string;
+        get graphqlArgs(): Type<ResolvedTypeT, ObjectUnionType>["graphqlArgs"];
+        graphqlResolveExpression({ variables, }: Parameters<_Type["graphqlResolveExpression"]>[0]): string;
     }
     export class OptionalObjectType<ResolvedTypeT extends OptionType<ObjectType | ObjectUnionType>, StubTypeT extends OptionType<ObjectType | ObjectUnionType>> extends SingleObjectType<ResolvedTypeT, StubTypeT> {
         constructor({ resolvedType, stubType, }: {