@shaclmate/compiler 4.0.60 → 4.0.61

package/dist/generators/ts/DefaultValueType.d.ts

@@ -18,6 +18,9 @@ export declare class DefaultValueType<ItemTypeT extends DefaultValueType.ItemTyp
     }] | readonly [{
         readonly instanceof: "Object";
         readonly typeof: "object";
+    }] | readonly [{
+        readonly instanceof: "Object";
+        readonly typeof: "object";
     }] | {
         readonly typeof: "bigint";
     }[] | readonly [{
@@ -35,17 +38,14 @@ export declare class DefaultValueType<ItemTypeT extends DefaultValueType.ItemTyp
     }] | readonly [{
         readonly instanceof: "Object";
         readonly typeof: "object";
-    }] | readonly [{
-        readonly instanceof: "Array";
-        readonly typeof: "object";
-    }] | readonly [{
-        readonly instanceof: "Object";
-        readonly typeof: "object";
     }] | readonly [{
         readonly instanceof: "Object";
         readonly typeof: "object";
     }] | readonly [{
         readonly typeof: "string";
+    }] | readonly [{
+        readonly instanceof: "Array";
+        readonly typeof: "object";
     }] | readonly [{
         readonly instanceof: "Object";
         readonly typeof: "object";

package/dist/generators/ts/DiscriminatedUnionType.d.ts

@@ -1,13 +1,13 @@
 import { Maybe } from "purify-ts";
+import type { DiscriminatedUnionType_Discriminant } from "./_DiscriminatedUnionType/DiscriminatedUnionType_Discriminant.js";
 import { AbstractType } from "./AbstractType.js";
 import type { BlankNodeType } from "./BlankNodeType.js";
 import type { IdentifierType } from "./IdentifierType.js";
 import type { IriType } from "./IriType.js";
 import type { Type } from "./Type.js";
-import type { Typeof } from "./Typeof.js";
 import { type Code } from "./ts-poet-wrapper.js";
 export declare class DiscriminatedUnionType<MemberTypeT extends Type> extends AbstractType {
-    private readonly discriminant;
+    protected readonly discriminant: DiscriminatedUnionType.Discriminant;
     readonly graphqlArgs: AbstractType["graphqlArgs"];
     readonly identifierType: Maybe<BlankNodeType | IdentifierType | IriType>;
     readonly kind: "ObjectDiscriminatedUnion" | "DiscriminatedUnion";
@@ -44,25 +44,7 @@ export declare class DiscriminatedUnionType<MemberTypeT extends Type> extends Ab
     get valueSparqlConstructTriplesFunction(): Code;
     get valueSparqlWherePatternsFunction(): Code;
     protected get schemaInitializers(): readonly Code[];
-    protected get schemaTypeExpression(): Code;
     protected get staticModuleDeclarations(): Record<string, Code>;
-    private get equalsFunctionExpression();
-    private get filterFunctionExpression();
-    private get filterTypeLiteral();
-    private get fromJsonFunctionExpression();
-    private get fromRdfResourceValuesFunctionExpression();
-    private get hashFunctionExpression();
-    /**
-     * An inline expression of this type rather than a type reference/name.
-     */
-    private get inlineExpression();
-    private get jsonSchemaExpression();
-    private get jsonTypeLiteral();
-    private get toJsonFunctionExpression();
-    private get toRdfResourceValuesFunctionExpression();
-    private get toStringFunctionExpression();
-    private get valueSparqlConstructTriplesFunctionExpression();
-    private get valueSparqlWherePatternsFunctionExpression();
     fromJsonExpression({ variables, }: Parameters<AbstractType["fromJsonExpression"]>[0]): Code;
     graphqlResolveExpression({ variables, }: {
         variables: {
@@ -77,39 +59,8 @@ export declare class DiscriminatedUnionType<MemberTypeT extends Type> extends Ab
     toStringExpression({ variables, }: Parameters<AbstractType["toStringExpression"]>[0]): Code;
     private readonly lazyMembers;
 }
-type Discriminant = ExtrinsicDiscriminant | HybridDiscriminant | IntrinsicDiscriminant | TypeofDiscriminant;
-type ExtrinsicDiscriminant = {
-    readonly jsonName: string;
-    readonly kind: "Extrinsic";
-    readonly memberValues: readonly AbstractType.DiscriminantProperty.Value[];
-    readonly name: string;
-};
-type HybridDiscriminant = {
-    readonly jsonName: string;
-    readonly kind: "Hybrid";
-    readonly memberValues: readonly {
-        readonly kind: "Extrinsic" | "Intrinsic";
-        readonly values: readonly AbstractType.DiscriminantProperty.Value[];
-    }[];
-    readonly name: string;
-};
-type IntrinsicDiscriminant = {
-    readonly jsonName: string;
-    readonly kind: "Intrinsic";
-    readonly memberValues: readonly AbstractType.DiscriminantProperty.Value[];
-    readonly name: string;
-};
-type TypeofDiscriminant = {
-    readonly kind: "Typeof";
-    readonly memberValues: readonly Typeof[];
-};
-export declare namespace Discriminant {
-    function infer(members: readonly {
-        readonly discriminantValue: Maybe<number | string>;
-        readonly type: Type;
-    }[]): Discriminant;
-}
 export declare namespace DiscriminatedUnionType {
+    type Discriminant = DiscriminatedUnionType_Discriminant;
     interface Member<TypeT extends Type> {
         readonly discriminantValues: readonly AbstractType.DiscriminantProperty.Value[];
         readonly jsonType: Code;
@@ -122,5 +73,4 @@ export declare namespace DiscriminatedUnionType {
         readonly wrap: (instance: Code) => Code;
     }
 }
-export {};
 //# sourceMappingURL=DiscriminatedUnionType.d.ts.map