@shaclmate/compiler 3.0.4 → 4.0.0

package/dist/generators/ts/ObjectUnionType.d.ts

@@ -1,101 +1,65 @@
-import { Maybe } from "purify-ts";
-import { type ModuleDeclarationStructure, type TypeAliasDeclarationStructure } from "ts-morph";
-import { DeclaredType } from "./DeclaredType.js";
+import { Maybe, NonEmptyList } from "purify-ts";
+import { MemberType } from "./_ObjectUnionType/MemberType.js";
+import { AbstractDeclaredType } from "./AbstractDeclaredType.js";
+import type { BlankNodeType } from "./BlankNodeType.js";
 import type { IdentifierType } from "./IdentifierType.js";
-import type { Import } from "./Import.js";
+import type { IriType } from "./IriType.js";
 import type { ObjectType } from "./ObjectType.js";
-import { Type } from "./Type.js";
-declare class MemberType {
-    private readonly delegate;
-    private readonly universe;
-    constructor({ delegate, universe, }: {
-        delegate: ObjectType;
-        universe: readonly ObjectType[];
-    });
-    get declarationType(): import("../../enums/TsObjectDeclarationType.js").TsObjectDeclarationType;
-    get descendantFromRdfTypeVariables(): readonly string[];
-    get discriminatorPropertyValues(): readonly string[];
-    get features(): Set<import("../../enums/TsFeature.js").TsFeature>;
-    get fromRdfType(): Maybe<import("@rdfjs/types").NamedNode<string>>;
-    get fromRdfTypeVariable(): Maybe<string>;
-    get graphqlName(): Type.GraphqlName;
-    get identifierTypeAlias(): string;
-    get jsonName(): Type.JsonName;
-    get mutable(): boolean;
-    get name(): string;
-    get staticModuleName(): string;
-    get toRdfjsResourceType(): string;
-    jsonZodSchema(parameters: Parameters<DeclaredType["jsonZodSchema"]>[0]): string;
-    newExpression(parameters: Parameters<ObjectType["newExpression"]>[0]): string;
-    snippetDeclarations(parameters: Parameters<DeclaredType["snippetDeclarations"]>[0]): readonly string[];
-    useImports(): readonly Import[];
-}
+import { type Code } from "./ts-poet-wrapper.js";
 /**
  * A union of object types, generated as a type alias
  *
  *   type SomeUnion = Member1 | Member2 | ...
  *
- * with associated functions that switch on the type discriminator property and delegate to the appropriate
+ * with associated functions that switch on the type discriminant property and delegate to the appropriate
  * member type code.
  *
  * It also generates SPARQL graph patterns that UNION the member object types.
  */
-export declare class ObjectUnionType extends DeclaredType {
-    private readonly _discriminatorProperty;
-    private readonly comment;
-    private readonly label;
-    readonly identifierType: IdentifierType;
+export declare class ObjectUnionType extends AbstractDeclaredType {
+    readonly graphqlArgs: AbstractDeclaredType["graphqlArgs"];
+    readonly identifierType: BlankNodeType | IdentifierType | IriType;
     readonly kind = "ObjectUnionType";
     readonly memberTypes: readonly MemberType[];
-    readonly typeof = "object";
-    constructor({ comment, identifierType, label, memberTypes, ...superParameters }: ConstructorParameters<typeof DeclaredType>[0] & {
+    readonly typeofs: NonEmptyList<"object">;
+    constructor({ identifierType, memberTypes, ...superParameters }: ConstructorParameters<typeof AbstractDeclaredType>[0] & {
         comment: Maybe<string>;
         export_: boolean;
-        identifierType: IdentifierType;
+        identifierType: BlankNodeType | IdentifierType | IriType;
         label: Maybe<string>;
         memberTypes: readonly ObjectType[];
         name: string;
     });
-    get conversions(): readonly Type.Conversion[];
-    get declarationImports(): readonly Import[];
-    get declarations(): (ModuleDeclarationStructure | TypeAliasDeclarationStructure)[];
-    get discriminatorProperty(): Maybe<Type.DiscriminatorProperty>;
-    get equalsFunction(): string;
-    get graphqlName(): Type.GraphqlName;
-    get identifierTypeAlias(): string;
-    get jsonName(): Type.JsonName;
+    get conversions(): readonly AbstractDeclaredType.Conversion[];
+    get declaration(): Code;
+    get discriminantProperty(): Maybe<AbstractDeclaredType.DiscriminantProperty>;
+    get equalsFunction(): Code;
+    get filterFunction(): Code;
+    get filterType(): Code;
+    get graphqlType(): AbstractDeclaredType.GraphqlType;
+    get identifierTypeAlias(): Code;
     get mutable(): boolean;
     get objectSetMethodNames(): ObjectType.ObjectSetMethodNames;
+    get schema(): Code;
+    get schemaType(): Code;
+    get sparqlConstructTriplesFunction(): Code;
+    get sparqlWherePatternsFunction(): Code;
     get staticModuleName(): string;
-    protected get thisVariable(): string;
-    private get equalsFunctionDeclaration();
-    private get fromJsonFunctionDeclaration();
-    private get fromRdfFunctionDeclaration();
-    private get graphqlTypeVariableStatement();
-    private get hashFunctionDeclaration();
-    private get identifierTypeDeclarations();
-    private get jsonTypeAliasDeclaration();
-    private get jsonZodSchemaFunctionDeclaration();
-    private get sparqlFunctionDeclarations();
-    private get toJsonFunctionDeclaration();
-    private get toRdfFunctionDeclaration();
-    private get typeAliasDeclaration();
-    fromJsonExpression({ variables, }: Parameters<Type["fromJsonExpression"]>[0]): string;
-    fromRdfExpression({ variables, }: Parameters<Type["fromRdfExpression"]>[0]): string;
+    protected get _discriminantProperty(): AbstractDeclaredType.DiscriminantProperty;
+    protected get concreteMemberTypes(): readonly MemberType[];
+    protected get thisVariable(): Code;
+    fromJsonExpression({ variables, }: Parameters<AbstractDeclaredType["fromJsonExpression"]>[0]): Code;
+    fromRdfExpression({ variables, }: Parameters<AbstractDeclaredType["fromRdfExpression"]>[0]): Code;
     graphqlResolveExpression({ variables, }: {
         variables: {
-            value: string;
+            value: Code;
         };
-    }): string;
-    hashStatements({ variables, }: Parameters<Type["hashStatements"]>[0]): readonly string[];
-    jsonUiSchemaElement(): Maybe<string>;
-    jsonZodSchema(): ReturnType<Type["jsonZodSchema"]>;
-    snippetDeclarations(parameters: Parameters<DeclaredType["snippetDeclarations"]>[0]): readonly string[];
-    sparqlConstructTemplateTriples(parameters: Parameters<Type["sparqlConstructTemplateTriples"]>[0]): readonly string[];
-    sparqlWherePatterns(parameters: Parameters<Type["sparqlWherePatterns"]>[0]): readonly string[];
-    toJsonExpression({ variables, }: Parameters<Type["toJsonExpression"]>[0]): string;
-    toRdfExpression({ variables, }: Parameters<Type["toRdfExpression"]>[0]): string;
-    useImports(): readonly Import[];
+    }): Code;
+    hashStatements({ variables, }: Parameters<AbstractDeclaredType["hashStatements"]>[0]): readonly Code[];
+    jsonType(): AbstractDeclaredType.JsonType;
+    jsonUiSchemaElement(): Maybe<Code>;
+    jsonZodSchema({ context, }: Parameters<AbstractDeclaredType["jsonZodSchema"]>[0]): Code;
+    toJsonExpression({ variables, }: Parameters<AbstractDeclaredType["toJsonExpression"]>[0]): Code;
+    toRdfExpression({ variables, }: Parameters<AbstractDeclaredType["toRdfExpression"]>[0]): Code;
 }
-export {};
 //# sourceMappingURL=ObjectUnionType.d.ts.map