@shaclmate/compiler 3.0.4 → 4.0.0

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

@@ -1,189 +0,0 @@
-import { Maybe } from "purify-ts";
-import { StructureKind } from "ts-morph";
-import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
-import { toJsonFunctionOrMethodDeclaration } from "./toJsonFunctionOrMethodDeclaration.js";
-function fromJsonFunctionDeclarations() {
-    const deserializePropertiesReturnType = [];
-    const initializers = [];
-    const propertyReturnTypeSignatures = [];
-    const propertiesFromJsonStatements = [];
-    propertiesFromJsonStatements.push(`const ${syntheticNamePrefix}jsonSafeParseResult = ${syntheticNamePrefix}jsonZodSchema().safeParse(_json);`, `if (!${syntheticNamePrefix}jsonSafeParseResult.success) { return purify.Left(${syntheticNamePrefix}jsonSafeParseResult.error); }`, `const ${variables.jsonObject} = ${syntheticNamePrefix}jsonSafeParseResult.data;`);
-    this.parentObjectTypes.forEach((parentObjectType, parentObjectTypeI) => {
-        propertiesFromJsonStatements.push(`const ${syntheticNamePrefix}super${parentObjectTypeI}Either = ${parentObjectType.staticModuleName}.${syntheticNamePrefix}propertiesFromJson(${variables.jsonObject});`, `if (${syntheticNamePrefix}super${parentObjectTypeI}Either.isLeft()) { return ${syntheticNamePrefix}super${parentObjectTypeI}Either; }`, `const ${syntheticNamePrefix}super${parentObjectTypeI} = ${syntheticNamePrefix}super${parentObjectTypeI}Either.unsafeCoerce()`);
-        initializers.push(`...${syntheticNamePrefix}super${parentObjectTypeI}`);
-        deserializePropertiesReturnType.push(`${syntheticNamePrefix}UnwrapR<ReturnType<typeof ${parentObjectType.staticModuleName}.${syntheticNamePrefix}propertiesFromJson>>`);
-    });
-    for (const property of this.properties) {
-        const propertyFromJsonStatements = property.fromJsonStatements({
-            variables,
-        });
-        if (propertyFromJsonStatements.length > 0) {
-            propertiesFromJsonStatements.push(...propertyFromJsonStatements);
-            initializers.push(property.name);
-            propertyReturnTypeSignatures.push(`${property.name}: ${property.type.name};`);
-        }
-    }
-    propertiesFromJsonStatements.push(`return purify.Either.of({ ${initializers.join(", ")} })`);
-    if (propertyReturnTypeSignatures.length > 0) {
-        deserializePropertiesReturnType.splice(0, 0, `{ ${propertyReturnTypeSignatures.join(" ")} }`);
-    }
-    const functionDeclarations = [];
-    functionDeclarations.push({
-        isExported: true,
-        kind: StructureKind.Function,
-        name: `${syntheticNamePrefix}propertiesFromJson`,
-        parameters: [
-            {
-                name: "_json",
-                type: "unknown",
-            },
-        ],
-        returnType: `purify.Either<zod.ZodError, ${deserializePropertiesReturnType.join(" & ")}>`,
-        statements: propertiesFromJsonStatements,
-    });
-    let fromJsonStatements;
-    if (this.abstract) {
-        if (this.childObjectTypes.length > 0) {
-            // Similar to an object union type, alt-chain the fromJson of the different concrete subclasses together
-            fromJsonStatements = [
-                `return ${this.childObjectTypes.reduce((expression, childObjectType) => {
-                    const childObjectTypeExpression = `(${childObjectType.staticModuleName}.${syntheticNamePrefix}fromJson(json) as purify.Either<zod.ZodError, ${this.name}>)`;
-                    return expression.length > 0
-                        ? `${expression}.altLazy(() => ${childObjectTypeExpression})`
-                        : childObjectTypeExpression;
-                }, "")};`,
-            ];
-        }
-        else {
-            fromJsonStatements = [];
-        }
-    }
-    else {
-        let propertiesFromJsonExpression = `${syntheticNamePrefix}propertiesFromJson(json)`;
-        if (this.declarationType === "class") {
-            propertiesFromJsonExpression = `${propertiesFromJsonExpression}.map(properties => new ${this.name}(properties))`;
-        }
-        if (this.childObjectTypes.length > 0) {
-            fromJsonStatements = [
-                `return ${this.childObjectTypes.reduce((expression, childObjectType) => {
-                    const childObjectTypeExpression = `(${childObjectType.staticModuleName}.${syntheticNamePrefix}fromJson(json) as purify.Either<zod.ZodError, ${this.name}>)`;
-                    return expression.length > 0
-                        ? `${expression}.altLazy(() => ${childObjectTypeExpression})`
-                        : childObjectTypeExpression;
-                }, "")}.altLazy(() => ${propertiesFromJsonExpression});`,
-            ];
-        }
-        else {
-            fromJsonStatements = [`return ${propertiesFromJsonExpression};`];
-        }
-    }
-    if (fromJsonStatements.length > 0) {
-        functionDeclarations.push({
-            isExported: true,
-            kind: StructureKind.Function,
-            name: `${syntheticNamePrefix}fromJson`,
-            parameters: [
-                {
-                    name: "json",
-                    type: "unknown",
-                },
-            ],
-            returnType: `purify.Either<zod.ZodError, ${this.name}>`,
-            statements: fromJsonStatements,
-        });
-    }
-    return functionDeclarations;
-}
-function jsonSchemaFunctionDeclaration() {
-    return {
-        isExported: true,
-        kind: StructureKind.Function,
-        name: `${syntheticNamePrefix}jsonSchema`,
-        statements: [
-            `return zod.toJSONSchema(${syntheticNamePrefix}jsonZodSchema());`,
-        ],
-    };
-}
-function jsonUiSchemaFunctionDeclaration() {
-    const variables = { scopePrefix: "scopePrefix" };
-    const elements = this.parentObjectTypes
-        .map((parentObjectType) => `${parentObjectType.staticModuleName}.${syntheticNamePrefix}jsonUiSchema({ scopePrefix })`)
-        .concat(this.ownProperties.flatMap((property) => property.jsonUiSchemaElement({ variables }).toList()));
-    return {
-        isExported: true,
-        kind: StructureKind.Function,
-        name: `${syntheticNamePrefix}jsonUiSchema`,
-        parameters: [
-            {
-                hasQuestionToken: true,
-                name: "parameters",
-                type: "{ scopePrefix?: string }",
-            },
-        ],
-        returnType: "any",
-        statements: [
-            'const scopePrefix = parameters?.scopePrefix ?? "#";',
-            `return { "elements": [ ${elements.join(", ")} ], label: "${this.label.orDefault(this.name)}", type: "Group" }`,
-        ],
-    };
-}
-function jsonZodSchemaFunctionDeclaration() {
-    const variables = { zod: "zod" };
-    const mergeZodObjectSchemas = [];
-    for (const parentObjectType of this.parentObjectTypes) {
-        mergeZodObjectSchemas.push(`${parentObjectType.jsonZodSchema({ context: "type", variables })}`);
-    }
-    if (this.properties.length > 0) {
-        mergeZodObjectSchemas.push(`${variables.zod}.object({ ${this.properties
-            .flatMap((property) => property.jsonZodSchema({ variables }).toList())
-            .map(({ key, schema }) => `"${key}": ${schema}`)
-            .join(",")} })`);
-    }
-    return {
-        isExported: true,
-        kind: StructureKind.Function,
-        name: `${syntheticNamePrefix}jsonZodSchema`,
-        statements: [
-            `return ${mergeZodObjectSchemas.length > 0
-                ? mergeZodObjectSchemas.reduce((merged, zodObjectSchema) => {
-                    if (merged.length === 0) {
-                        return zodObjectSchema;
-                    }
-                    return `${merged}.merge(${zodObjectSchema})`;
-                }, "")
-                : `${variables.zod}.object()`} satisfies zod.ZodType<${syntheticNamePrefix}Json>;`,
-        ],
-    };
-}
-function toJsonFunctionDeclaration() {
-    if (this.declarationType !== "interface") {
-        return Maybe.empty();
-    }
-    return toJsonFunctionOrMethodDeclaration
-        .bind(this)()
-        .map((toJsonFunctionOrMethodDeclaration) => ({
-        ...toJsonFunctionOrMethodDeclaration,
-        isExported: true,
-        kind: StructureKind.Function,
-        name: `${syntheticNamePrefix}toJson`,
-    }));
-}
-export function jsonFunctionDeclarations() {
-    if (!this.features.has("json")) {
-        return [];
-    }
-    if (this.extern) {
-        return [];
-    }
-    return [
-        ...fromJsonFunctionDeclarations.bind(this)(),
-        jsonSchemaFunctionDeclaration.bind(this)(),
-        jsonUiSchemaFunctionDeclaration.bind(this)(),
-        ...toJsonFunctionDeclaration.bind(this)().toList(),
-        jsonZodSchemaFunctionDeclaration.bind(this)(),
-    ];
-}
-const variables = {
-    jsonObject: `${syntheticNamePrefix}jsonObject`,
-};
-//# sourceMappingURL=jsonFunctionDeclarations.js.map

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

@@ -1,5 +0,0 @@
-import { Maybe } from "purify-ts";
-import { type TypeAliasDeclarationStructure } from "ts-morph";
-import type { ObjectType } from "../ObjectType.js";
-export declare function jsonTypeAliasDeclaration(this: ObjectType): Maybe<TypeAliasDeclarationStructure>;
-//# sourceMappingURL=jsonTypeAliasDeclaration.d.ts.map

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

@@ -1,28 +0,0 @@
-import { Maybe } from "purify-ts";
-import { StructureKind } from "ts-morph";
-import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
-export function jsonTypeAliasDeclaration() {
-    if (!this.features.has("json")) {
-        return Maybe.empty();
-    }
-    if (this.extern) {
-        return Maybe.empty();
-    }
-    const members = [];
-    if (this.ownProperties.length > 0) {
-        members.push(`{ ${this.ownProperties
-            .flatMap((property) => property.jsonPropertySignature.toList())
-            .map((propertySignature) => `readonly "${propertySignature.name}"${propertySignature.hasQuestionToken ? "?" : ""}: ${propertySignature.type}`)
-            .join("; ")} }`);
-    }
-    for (const parentObjectType of this.parentObjectTypes) {
-        members.push(parentObjectType.jsonName.toString());
-    }
-    return Maybe.of({
-        isExported: true,
-        kind: StructureKind.TypeAlias,
-        name: `${syntheticNamePrefix}Json`,
-        type: members.length > 0 ? members.join(" & ") : "object",
-    });
-}
-//# sourceMappingURL=jsonTypeAliasDeclaration.js.map

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

@@ -1,9 +0,0 @@
-export declare function objectSetMethodNames(this: {
-    readonly name: string;
-}): {
-    object: string;
-    objectIdentifiers: string;
-    objects: string;
-    objectsCount: string;
-};
-//# sourceMappingURL=objectSetMethodNames.d.ts.map

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

@@ -1,5 +0,0 @@
-import { Maybe } from "purify-ts";
-import { type VariableStatementStructure } from "ts-morph";
-import type { ObjectType } from "../ObjectType.js";
-export declare function propertiesVariableStatement(this: ObjectType): Maybe<VariableStatementStructure>;
-//# sourceMappingURL=propertiesVariableStatement.d.ts.map

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

@@ -1,37 +0,0 @@
-import { Maybe } from "purify-ts";
-import { StructureKind, VariableDeclarationKind, } from "ts-morph";
-import { objectInitializer } from "../objectInitializer.js";
-import { rdfjsTermExpression } from "../rdfjsTermExpression.js";
-import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
-import { ShaclProperty } from "./ShaclProperty.js";
-export function propertiesVariableStatement() {
-    if (this.extern) {
-        return Maybe.empty();
-    }
-    const propertiesObject = [];
-    for (const parentObjectType of this.parentObjectTypes) {
-        propertiesObject.push(`...${parentObjectType.staticModuleName}.${syntheticNamePrefix}properties`);
-    }
-    for (const property of this.properties) {
-        if (!(property instanceof ShaclProperty)) {
-            continue;
-        }
-        const propertyObject = {};
-        if (this.features.has("rdf")) {
-            propertyObject["identifier"] = rdfjsTermExpression(property.path);
-        }
-        propertiesObject.push(`${property.name}: ${objectInitializer(propertyObject)}`);
-    }
-    return Maybe.of({
-        declarationKind: VariableDeclarationKind.Const,
-        kind: StructureKind.VariableStatement,
-        declarations: [
-            {
-                name: `${syntheticNamePrefix}properties`,
-                initializer: `{${propertiesObject.join(", ")}}`,
-            },
-        ],
-        isExported: true,
-    });
-}
-//# sourceMappingURL=propertiesVariableStatement.js.map

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

@@ -1,4 +0,0 @@
-import { type FunctionDeclarationStructure } from "ts-morph";
-import type { ObjectType } from "../ObjectType.js";
-export declare function rdfFunctionDeclarations(this: ObjectType): readonly FunctionDeclarationStructure[];
-//# sourceMappingURL=rdfFunctionDeclarations.d.ts.map

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

@@ -1,169 +0,0 @@
-import { rdf } from "@tpluscode/rdf-ns-builders";
-import { Maybe } from "purify-ts";
-import { invariant } from "ts-invariant";
-import { StructureKind } from "ts-morph";
-import { rdfjsTermExpression } from "../rdfjsTermExpression.js";
-import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
-import { toRdfFunctionOrMethodDeclaration } from "./toRdfFunctionOrMethodDeclaration.js";
-function fromRdfFunctionDeclaration() {
-    const statements = [];
-    statements.push("let { ignoreRdfType = false, objectSet, preferredLanguages, ...context } = (options ?? {});", `if (!objectSet) { objectSet = new ${syntheticNamePrefix}RdfjsDatasetObjectSet({ dataset: resource.dataset }); }`);
-    let returnExpression;
-    if (this.childObjectTypes.length > 0) {
-        // Can't ignore the RDF type.
-        // Similar to an object union type, alt-chain the fromRdf of the different concrete subclasses together
-        returnExpression = this.childObjectTypes.reduce((expression, childObjectType) => {
-            const childObjectTypeExpression = `(${childObjectType.staticModuleName}.${syntheticNamePrefix}fromRdf(resource, { ...context, ignoreRdfType: false, objectSet }) as purify.Either<Error, ${this.name}>)`;
-            return expression.length > 0
-                ? `${expression}.altLazy(() => ${childObjectTypeExpression})`
-                : childObjectTypeExpression;
-        }, "");
-    }
-    if (!this.abstract) {
-        let propertiesFromRdfExpression = `${this.staticModuleName}.${syntheticNamePrefix}propertiesFromRdf({ ...context, ignoreRdfType, objectSet, preferredLanguages, resource })`;
-        if (this.declarationType === "class") {
-            propertiesFromRdfExpression = `${propertiesFromRdfExpression}.map(properties => new ${this.name}(properties))`;
-        }
-        if (this.childObjectTypes.length > 0) {
-            invariant(returnExpression);
-            returnExpression = `${returnExpression}.altLazy(() => ${propertiesFromRdfExpression})`;
-        }
-        else {
-            invariant(!returnExpression);
-            returnExpression = propertiesFromRdfExpression;
-        }
-    }
-    if (returnExpression) {
-        statements.push(`return ${returnExpression};`);
-    }
-    if (statements.length === 0) {
-        return Maybe.empty();
-    }
-    return Maybe.of({
-        isExported: true,
-        kind: StructureKind.Function,
-        name: `${syntheticNamePrefix}fromRdf`,
-        parameters: [
-            {
-                name: "resource",
-                type: "rdfjsResource.Resource",
-            },
-            {
-                hasQuestionToken: true,
-                name: "options",
-                type: `{ [_index: string]: any; ignoreRdfType?: boolean; objectSet?: ${syntheticNamePrefix}ObjectSet; preferredLanguages?: readonly string[]; }`,
-            },
-        ],
-        returnType: `purify.Either<Error, ${this.name}>`,
-        statements: statements,
-    });
-}
-function propertiesFromRdfFunctionDeclaration() {
-    const initializers = [];
-    const propertySignatures = [];
-    const returnType = [];
-    const statements = [];
-    this.parentObjectTypes.forEach((parentObjectType, parentObjectTypeI) => {
-        statements.push(`const ${syntheticNamePrefix}super${parentObjectTypeI}Either = ${parentObjectType.staticModuleName}.${syntheticNamePrefix}propertiesFromRdf({ ...${variables.context}, ignoreRdfType: true, objectSet: ${variables.objectSet}, preferredLanguages: ${variables.preferredLanguages}, resource: ${variables.resource} });`, `if (${syntheticNamePrefix}super${parentObjectTypeI}Either.isLeft()) { return ${syntheticNamePrefix}super${parentObjectTypeI}Either; }`, `const ${syntheticNamePrefix}super${parentObjectTypeI} = ${syntheticNamePrefix}super${parentObjectTypeI}Either.unsafeCoerce()`);
-        initializers.push(`...${syntheticNamePrefix}super${parentObjectTypeI}`);
-        returnType.push(`${syntheticNamePrefix}UnwrapR<ReturnType<typeof ${parentObjectType.staticModuleName}.${syntheticNamePrefix}propertiesFromRdf>>`);
-    });
-    this.fromRdfType.ifJust((fromRdfType) => {
-        const fromRdfTypeVariable = this.fromRdfTypeVariable.unsafeCoerce();
-        const predicate = rdfjsTermExpression(rdf.type);
-        // Check the expected type and its known subtypes
-        const cases = new Set();
-        cases.add(fromRdfType.value);
-        for (const descendantFromRdfType of this.descendantFromRdfTypes) {
-            cases.add(descendantFromRdfType.value);
-        }
-        statements.push(`\
-if (!${variables.ignoreRdfType}) {
-  const ${syntheticNamePrefix}rdfTypeCheck: purify.Either<Error, true> = ${variables.resource}.value(${predicate})
-    .chain(actualRdfType => actualRdfType.toIri())
-    .chain((actualRdfType) => {
-      // Check the expected type and its known subtypes
-      switch (actualRdfType.value) {
-        ${[...cases].map((fromRdfType) => `case "${fromRdfType}":`).join("\n")}
-          return purify.Either.of(true);
-      }
-
-      // Check arbitrary rdfs:subClassOf's of the expected type
-      if (${variables.resource}.isInstanceOf(${fromRdfTypeVariable})) {
-        return purify.Either.of(true);
-      }
-
-      return purify.Left(new Error(\`\${rdfjsResource.Resource.Identifier.toString(${variables.resource}.identifier)} has unexpected RDF type (actual: \${actualRdfType.value}, expected: ${fromRdfType.value})\`));
-    });
-  if (${syntheticNamePrefix}rdfTypeCheck.isLeft()) {
-    return ${syntheticNamePrefix}rdfTypeCheck;
-  }
-}`);
-    });
-    const propertyFromRdfVariables = {
-        context: variables.context,
-        preferredLanguages: variables.preferredLanguages,
-        objectSet: variables.objectSet,
-        resource: variables.resource,
-    };
-    for (const property of this.properties) {
-        const propertyFromRdfStatements = property.fromRdfStatements({
-            variables: propertyFromRdfVariables,
-        });
-        if (propertyFromRdfStatements.length > 0) {
-            statements.push(...propertyFromRdfStatements);
-            initializers.push(property.name);
-            propertySignatures.push(`${property.name}: ${property.type.name};`);
-        }
-    }
-    statements.push(`return purify.Either.of({ ${initializers.join(", ")} })`);
-    if (propertySignatures.length > 0) {
-        returnType.splice(0, 0, `{ ${propertySignatures.join(" ")} }`);
-    }
-    return {
-        isExported: true,
-        kind: StructureKind.Function,
-        name: `${syntheticNamePrefix}propertiesFromRdf`,
-        parameters: [
-            {
-                name: `{ ignoreRdfType: ${variables.ignoreRdfType}, objectSet: ${variables.objectSet}, preferredLanguages: ${variables.preferredLanguages}, resource: ${variables.resource},\n// @ts-ignore\n...${variables.context} }`,
-                type: `{ [_index: string]: any; ignoreRdfType: boolean; objectSet: ${syntheticNamePrefix}ObjectSet; preferredLanguages?: readonly string[]; resource: rdfjsResource.Resource; }`,
-            },
-        ],
-        returnType: `purify.Either<Error, ${returnType.join(" & ")}>`,
-        statements: statements,
-    };
-}
-export function rdfFunctionDeclarations() {
-    if (!this.features.has("rdf")) {
-        return [];
-    }
-    if (this.extern) {
-        return [];
-    }
-    return [
-        ...fromRdfFunctionDeclaration.bind(this)().toList(),
-        propertiesFromRdfFunctionDeclaration.bind(this)(),
-        ...toRdfFunctionDeclaration.bind(this)().toList(),
-    ];
-}
-function toRdfFunctionDeclaration() {
-    if (this.declarationType !== "interface") {
-        return Maybe.empty();
-    }
-    return toRdfFunctionOrMethodDeclaration
-        .bind(this)()
-        .map((toRdfFunctionOrMethodDeclaration) => ({
-        ...toRdfFunctionOrMethodDeclaration,
-        isExported: true,
-        kind: StructureKind.Function,
-    }));
-}
-const variables = {
-    context: `${syntheticNamePrefix}context`,
-    ignoreRdfType: `${syntheticNamePrefix}ignoreRdfType`,
-    objectSet: `${syntheticNamePrefix}objectSet`,
-    preferredLanguages: `${syntheticNamePrefix}preferredLanguages`,
-    resource: `${syntheticNamePrefix}resource`,
-};
-//# sourceMappingURL=rdfFunctionDeclarations.js.map

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

@@ -1,5 +0,0 @@
-import { type FunctionDeclarationStructure } from "ts-morph";
-export declare function sparqlConstructQueryFunctionDeclaration(this: {
-    readonly staticModuleName: string;
-}): FunctionDeclarationStructure;
-//# sourceMappingURL=sparqlConstructQueryFunctionDeclaration.d.ts.map

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

@@ -1,22 +0,0 @@
-import { StructureKind } from "ts-morph";
-import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
-export function sparqlConstructQueryFunctionDeclaration() {
-    return {
-        kind: StructureKind.Function,
-        isExported: true,
-        name: `${syntheticNamePrefix}sparqlConstructQuery`,
-        parameters: [
-            {
-                hasQuestionToken: true,
-                name: "parameters",
-                type: '{ ignoreRdfType?: boolean; prefixes?: { [prefix: string]: string }; preferredLanguages?: readonly string[]; subject?: sparqljs.Triple["subject"]; } & Omit<sparqljs.ConstructQuery, "prefixes" | "queryType" | "type">',
-            },
-        ],
-        returnType: "sparqljs.ConstructQuery",
-        statements: [
-            "const { ignoreRdfType, preferredLanguages, subject, ...queryParameters } = parameters ?? {}",
-            `return { ...queryParameters, prefixes: parameters?.prefixes ?? {}, queryType: "CONSTRUCT", template: (queryParameters.template ?? []).concat(${this.staticModuleName}.${syntheticNamePrefix}sparqlConstructTemplateTriples({ ignoreRdfType, subject })), type: "query", where: (queryParameters.where ?? []).concat(${this.staticModuleName}.${syntheticNamePrefix}sparqlWherePatterns({ ignoreRdfType, preferredLanguages, subject })) };`,
-        ],
-    };
-}
-//# sourceMappingURL=sparqlConstructQueryFunctionDeclaration.js.map

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

@@ -1,5 +0,0 @@
-import { type FunctionDeclarationStructure } from "ts-morph";
-export declare function sparqlConstructQueryStringFunctionDeclaration(this: {
-    readonly staticModuleName: string;
-}): FunctionDeclarationStructure;
-//# sourceMappingURL=sparqlConstructQueryStringFunctionDeclaration.d.ts.map

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

@@ -1,21 +0,0 @@
-import { StructureKind } from "ts-morph";
-import { syntheticNamePrefix } from "../syntheticNamePrefix.js";
-export function sparqlConstructQueryStringFunctionDeclaration() {
-    return {
-        isExported: true,
-        kind: StructureKind.Function,
-        name: `${syntheticNamePrefix}sparqlConstructQueryString`,
-        parameters: [
-            {
-                hasQuestionToken: true,
-                name: "parameters",
-                type: '{ ignoreRdfType?: boolean; preferredLanguages?: readonly string[]; subject?: sparqljs.Triple["subject"]; variablePrefix?: string; } & Omit<sparqljs.ConstructQuery, "prefixes" | "queryType" | "type"> & sparqljs.GeneratorOptions',
-            },
-        ],
-        returnType: "string",
-        statements: [
-            `return new sparqljs.Generator(parameters).stringify(${this.staticModuleName}.${syntheticNamePrefix}sparqlConstructQuery(parameters));`,
-        ],
-    };
-}
-//# sourceMappingURL=sparqlConstructQueryStringFunctionDeclaration.js.map

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

@@ -1,4 +0,0 @@
-import { type FunctionDeclarationStructure } from "ts-morph";
-import type { ObjectType } from "../ObjectType.js";
-export declare function sparqlFunctionDeclarations(this: ObjectType): readonly FunctionDeclarationStructure[];
-//# sourceMappingURL=sparqlFunctionDeclarations.d.ts.map