npm - @syntrologie/adapt-gamification - Versions diffs - 2.3.0 → 2.4.0-canary.10 - Mend

@syntrologie/adapt-gamification 2.3.0 → 2.4.0-canary.10

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (4) hide show

package/dist/schema.d.ts CHANGED Viewed

@@ -147,16 +147,259 @@ export declare const AwardBadgeSchema: z.ZodObject<{
     badgeId: z.ZodString;
     anchorId: z.ZodOptional<z.ZodString>;
     label: z.ZodOptional<z.ZodString>;
+} & {
+    activation: z.ZodOptional<z.ZodObject<{
+        routes: z.ZodObject<{
+            include: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            exclude: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        }, "strip", z.ZodTypeAny, {
+            include?: string[] | undefined;
+            exclude?: string[] | undefined;
+        }, {
+            include?: string[] | undefined;
+            exclude?: string[] | undefined;
+        }>;
+        strategy: z.ZodOptional<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+            type: z.ZodLiteral<"rules">;
+            rules: z.ZodArray<z.ZodObject<{
+                conditions: z.ZodArray<z.ZodObject<{
+                    type: z.ZodString;
+                }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+                    type: z.ZodString;
+                }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+                    type: z.ZodString;
+                }, z.ZodTypeAny, "passthrough">>, "many">;
+                value: z.ZodUnknown;
+            }, "strip", z.ZodTypeAny, {
+                conditions: z.objectOutputType<{
+                    type: z.ZodString;
+                }, z.ZodTypeAny, "passthrough">[];
+                value?: unknown;
+            }, {
+                conditions: z.objectInputType<{
+                    type: z.ZodString;
+                }, z.ZodTypeAny, "passthrough">[];
+                value?: unknown;
+            }>, "many">;
+            default: z.ZodUnknown;
+        }, "strip", z.ZodTypeAny, {
+            type: "rules";
+            rules: {
+                conditions: z.objectOutputType<{
+                    type: z.ZodString;
+                }, z.ZodTypeAny, "passthrough">[];
+                value?: unknown;
+            }[];
+            default?: unknown;
+        }, {
+            type: "rules";
+            rules: {
+                conditions: z.objectInputType<{
+                    type: z.ZodString;
+                }, z.ZodTypeAny, "passthrough">[];
+                value?: unknown;
+            }[];
+            default?: unknown;
+        }>, z.ZodObject<{
+            type: z.ZodLiteral<"score">;
+            field: z.ZodString;
+            threshold: z.ZodNumber;
+            above: z.ZodUnknown;
+            below: z.ZodUnknown;
+        }, "strip", z.ZodTypeAny, {
+            type: "score";
+            field: string;
+            threshold: number;
+            above?: unknown;
+            below?: unknown;
+        }, {
+            type: "score";
+            field: string;
+            threshold: number;
+            above?: unknown;
+            below?: unknown;
+        }>, z.ZodObject<{
+            type: z.ZodLiteral<"model">;
+            modelId: z.ZodString;
+            inputs: z.ZodArray<z.ZodString, "many">;
+            outputMapping: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            default: z.ZodUnknown;
+        }, "strip", z.ZodTypeAny, {
+            type: "model";
+            modelId: string;
+            inputs: string[];
+            outputMapping: Record<string, unknown>;
+            default?: unknown;
+        }, {
+            type: "model";
+            modelId: string;
+            inputs: string[];
+            outputMapping: Record<string, unknown>;
+            default?: unknown;
+        }>, z.ZodObject<{
+            type: z.ZodLiteral<"external">;
+            endpoint: z.ZodString;
+            method: z.ZodOptional<z.ZodEnum<["GET", "POST"]>>;
+            default: z.ZodUnknown;
+            timeoutMs: z.ZodOptional<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            type: "external";
+            endpoint: string;
+            default?: unknown;
+            method?: "GET" | "POST" | undefined;
+            timeoutMs?: number | undefined;
+        }, {
+            type: "external";
+            endpoint: string;
+            default?: unknown;
+            method?: "GET" | "POST" | undefined;
+            timeoutMs?: number | undefined;
+        }>]>>;
+    }, "strip", z.ZodTypeAny, {
+        routes: {
+            include?: string[] | undefined;
+            exclude?: string[] | undefined;
+        };
+        strategy?: {
+            type: "rules";
+            rules: {
+                conditions: z.objectOutputType<{
+                    type: z.ZodString;
+                }, z.ZodTypeAny, "passthrough">[];
+                value?: unknown;
+            }[];
+            default?: unknown;
+        } | {
+            type: "score";
+            field: string;
+            threshold: number;
+            above?: unknown;
+            below?: unknown;
+        } | {
+            type: "model";
+            modelId: string;
+            inputs: string[];
+            outputMapping: Record<string, unknown>;
+            default?: unknown;
+        } | {
+            type: "external";
+            endpoint: string;
+            default?: unknown;
+            method?: "GET" | "POST" | undefined;
+            timeoutMs?: number | undefined;
+        } | undefined;
+    }, {
+        routes: {
+            include?: string[] | undefined;
+            exclude?: string[] | undefined;
+        };
+        strategy?: {
+            type: "rules";
+            rules: {
+                conditions: z.objectInputType<{
+                    type: z.ZodString;
+                }, z.ZodTypeAny, "passthrough">[];
+                value?: unknown;
+            }[];
+            default?: unknown;
+        } | {
+            type: "score";
+            field: string;
+            threshold: number;
+            above?: unknown;
+            below?: unknown;
+        } | {
+            type: "model";
+            modelId: string;
+            inputs: string[];
+            outputMapping: Record<string, unknown>;
+            default?: unknown;
+        } | {
+            type: "external";
+            endpoint: string;
+            default?: unknown;
+            method?: "GET" | "POST" | undefined;
+            timeoutMs?: number | undefined;
+        } | undefined;
+    }>>;
 }, "strip", z.ZodTypeAny, {
     badgeId: string;
     kind: "gamification:awardBadge";
     anchorId?: string | undefined;
     label?: string | undefined;
+    activation?: {
+        routes: {
+            include?: string[] | undefined;
+            exclude?: string[] | undefined;
+        };
+        strategy?: {
+            type: "rules";
+            rules: {
+                conditions: z.objectOutputType<{
+                    type: z.ZodString;
+                }, z.ZodTypeAny, "passthrough">[];
+                value?: unknown;
+            }[];
+            default?: unknown;
+        } | {
+            type: "score";
+            field: string;
+            threshold: number;
+            above?: unknown;
+            below?: unknown;
+        } | {
+            type: "model";
+            modelId: string;
+            inputs: string[];
+            outputMapping: Record<string, unknown>;
+            default?: unknown;
+        } | {
+            type: "external";
+            endpoint: string;
+            default?: unknown;
+            method?: "GET" | "POST" | undefined;
+            timeoutMs?: number | undefined;
+        } | undefined;
+    } | undefined;
 }, {
     badgeId: string;
     kind: "gamification:awardBadge";
     anchorId?: string | undefined;
     label?: string | undefined;
+    activation?: {
+        routes: {
+            include?: string[] | undefined;
+            exclude?: string[] | undefined;
+        };
+        strategy?: {
+            type: "rules";
+            rules: {
+                conditions: z.objectInputType<{
+                    type: z.ZodString;
+                }, z.ZodTypeAny, "passthrough">[];
+                value?: unknown;
+            }[];
+            default?: unknown;
+        } | {
+            type: "score";
+            field: string;
+            threshold: number;
+            above?: unknown;
+            below?: unknown;
+        } | {
+            type: "model";
+            modelId: string;
+            inputs: string[];
+            outputMapping: Record<string, unknown>;
+            default?: unknown;
+        } | {
+            type: "external";
+            endpoint: string;
+            default?: unknown;
+            method?: "GET" | "POST" | undefined;
+            timeoutMs?: number | undefined;
+        } | undefined;
+    } | undefined;
 }>;
 /**
  * Schema for adding points to a user's score.
@@ -166,16 +409,259 @@ export declare const AddPointsSchema: z.ZodObject<{
     points: z.ZodNumber;
     reason: z.ZodOptional<z.ZodString>;
     label: z.ZodOptional<z.ZodString>;
+} & {
+    activation: z.ZodOptional<z.ZodObject<{
+        routes: z.ZodObject<{
+            include: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            exclude: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        }, "strip", z.ZodTypeAny, {
+            include?: string[] | undefined;
+            exclude?: string[] | undefined;
+        }, {
+            include?: string[] | undefined;
+            exclude?: string[] | undefined;
+        }>;
+        strategy: z.ZodOptional<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+            type: z.ZodLiteral<"rules">;
+            rules: z.ZodArray<z.ZodObject<{
+                conditions: z.ZodArray<z.ZodObject<{
+                    type: z.ZodString;
+                }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+                    type: z.ZodString;
+                }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+                    type: z.ZodString;
+                }, z.ZodTypeAny, "passthrough">>, "many">;
+                value: z.ZodUnknown;
+            }, "strip", z.ZodTypeAny, {
+                conditions: z.objectOutputType<{
+                    type: z.ZodString;
+                }, z.ZodTypeAny, "passthrough">[];
+                value?: unknown;
+            }, {
+                conditions: z.objectInputType<{
+                    type: z.ZodString;
+                }, z.ZodTypeAny, "passthrough">[];
+                value?: unknown;
+            }>, "many">;
+            default: z.ZodUnknown;
+        }, "strip", z.ZodTypeAny, {
+            type: "rules";
+            rules: {
+                conditions: z.objectOutputType<{
+                    type: z.ZodString;
+                }, z.ZodTypeAny, "passthrough">[];
+                value?: unknown;
+            }[];
+            default?: unknown;
+        }, {
+            type: "rules";
+            rules: {
+                conditions: z.objectInputType<{
+                    type: z.ZodString;
+                }, z.ZodTypeAny, "passthrough">[];
+                value?: unknown;
+            }[];
+            default?: unknown;
+        }>, z.ZodObject<{
+            type: z.ZodLiteral<"score">;
+            field: z.ZodString;
+            threshold: z.ZodNumber;
+            above: z.ZodUnknown;
+            below: z.ZodUnknown;
+        }, "strip", z.ZodTypeAny, {
+            type: "score";
+            field: string;
+            threshold: number;
+            above?: unknown;
+            below?: unknown;
+        }, {
+            type: "score";
+            field: string;
+            threshold: number;
+            above?: unknown;
+            below?: unknown;
+        }>, z.ZodObject<{
+            type: z.ZodLiteral<"model">;
+            modelId: z.ZodString;
+            inputs: z.ZodArray<z.ZodString, "many">;
+            outputMapping: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            default: z.ZodUnknown;
+        }, "strip", z.ZodTypeAny, {
+            type: "model";
+            modelId: string;
+            inputs: string[];
+            outputMapping: Record<string, unknown>;
+            default?: unknown;
+        }, {
+            type: "model";
+            modelId: string;
+            inputs: string[];
+            outputMapping: Record<string, unknown>;
+            default?: unknown;
+        }>, z.ZodObject<{
+            type: z.ZodLiteral<"external">;
+            endpoint: z.ZodString;
+            method: z.ZodOptional<z.ZodEnum<["GET", "POST"]>>;
+            default: z.ZodUnknown;
+            timeoutMs: z.ZodOptional<z.ZodNumber>;
+        }, "strip", z.ZodTypeAny, {
+            type: "external";
+            endpoint: string;
+            default?: unknown;
+            method?: "GET" | "POST" | undefined;
+            timeoutMs?: number | undefined;
+        }, {
+            type: "external";
+            endpoint: string;
+            default?: unknown;
+            method?: "GET" | "POST" | undefined;
+            timeoutMs?: number | undefined;
+        }>]>>;
+    }, "strip", z.ZodTypeAny, {
+        routes: {
+            include?: string[] | undefined;
+            exclude?: string[] | undefined;
+        };
+        strategy?: {
+            type: "rules";
+            rules: {
+                conditions: z.objectOutputType<{
+                    type: z.ZodString;
+                }, z.ZodTypeAny, "passthrough">[];
+                value?: unknown;
+            }[];
+            default?: unknown;
+        } | {
+            type: "score";
+            field: string;
+            threshold: number;
+            above?: unknown;
+            below?: unknown;
+        } | {
+            type: "model";
+            modelId: string;
+            inputs: string[];
+            outputMapping: Record<string, unknown>;
+            default?: unknown;
+        } | {
+            type: "external";
+            endpoint: string;
+            default?: unknown;
+            method?: "GET" | "POST" | undefined;
+            timeoutMs?: number | undefined;
+        } | undefined;
+    }, {
+        routes: {
+            include?: string[] | undefined;
+            exclude?: string[] | undefined;
+        };
+        strategy?: {
+            type: "rules";
+            rules: {
+                conditions: z.objectInputType<{
+                    type: z.ZodString;
+                }, z.ZodTypeAny, "passthrough">[];
+                value?: unknown;
+            }[];
+            default?: unknown;
+        } | {
+            type: "score";
+            field: string;
+            threshold: number;
+            above?: unknown;
+            below?: unknown;
+        } | {
+            type: "model";
+            modelId: string;
+            inputs: string[];
+            outputMapping: Record<string, unknown>;
+            default?: unknown;
+        } | {
+            type: "external";
+            endpoint: string;
+            default?: unknown;
+            method?: "GET" | "POST" | undefined;
+            timeoutMs?: number | undefined;
+        } | undefined;
+    }>>;
 }, "strip", z.ZodTypeAny, {
     points: number;
     kind: "gamification:addPoints";
     reason?: string | undefined;
     label?: string | undefined;
+    activation?: {
+        routes: {
+            include?: string[] | undefined;
+            exclude?: string[] | undefined;
+        };
+        strategy?: {
+            type: "rules";
+            rules: {
+                conditions: z.objectOutputType<{
+                    type: z.ZodString;
+                }, z.ZodTypeAny, "passthrough">[];
+                value?: unknown;
+            }[];
+            default?: unknown;
+        } | {
+            type: "score";
+            field: string;
+            threshold: number;
+            above?: unknown;
+            below?: unknown;
+        } | {
+            type: "model";
+            modelId: string;
+            inputs: string[];
+            outputMapping: Record<string, unknown>;
+            default?: unknown;
+        } | {
+            type: "external";
+            endpoint: string;
+            default?: unknown;
+            method?: "GET" | "POST" | undefined;
+            timeoutMs?: number | undefined;
+        } | undefined;
+    } | undefined;
 }, {
     points: number;
     kind: "gamification:addPoints";
     reason?: string | undefined;
     label?: string | undefined;
+    activation?: {
+        routes: {
+            include?: string[] | undefined;
+            exclude?: string[] | undefined;
+        };
+        strategy?: {
+            type: "rules";
+            rules: {
+                conditions: z.objectInputType<{
+                    type: z.ZodString;
+                }, z.ZodTypeAny, "passthrough">[];
+                value?: unknown;
+            }[];
+            default?: unknown;
+        } | {
+            type: "score";
+            field: string;
+            threshold: number;
+            above?: unknown;
+            below?: unknown;
+        } | {
+            type: "model";
+            modelId: string;
+            inputs: string[];
+            outputMapping: Record<string, unknown>;
+            default?: unknown;
+        } | {
+            type: "external";
+            endpoint: string;
+            default?: unknown;
+            method?: "GET" | "POST" | undefined;
+            timeoutMs?: number | undefined;
+        } | undefined;
+    } | undefined;
 }>;
 /**
  * Action step schemas for unified JSON Schema generation.
@@ -189,16 +675,259 @@ export declare const actionStepSchemas: ({
         badgeId: z.ZodString;
         anchorId: z.ZodOptional<z.ZodString>;
         label: z.ZodOptional<z.ZodString>;
+    } & {
+        activation: z.ZodOptional<z.ZodObject<{
+            routes: z.ZodObject<{
+                include: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+                exclude: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            }, "strip", z.ZodTypeAny, {
+                include?: string[] | undefined;
+                exclude?: string[] | undefined;
+            }, {
+                include?: string[] | undefined;
+                exclude?: string[] | undefined;
+            }>;
+            strategy: z.ZodOptional<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+                type: z.ZodLiteral<"rules">;
+                rules: z.ZodArray<z.ZodObject<{
+                    conditions: z.ZodArray<z.ZodObject<{
+                        type: z.ZodString;
+                    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+                        type: z.ZodString;
+                    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+                        type: z.ZodString;
+                    }, z.ZodTypeAny, "passthrough">>, "many">;
+                    value: z.ZodUnknown;
+                }, "strip", z.ZodTypeAny, {
+                    conditions: z.objectOutputType<{
+                        type: z.ZodString;
+                    }, z.ZodTypeAny, "passthrough">[];
+                    value?: unknown;
+                }, {
+                    conditions: z.objectInputType<{
+                        type: z.ZodString;
+                    }, z.ZodTypeAny, "passthrough">[];
+                    value?: unknown;
+                }>, "many">;
+                default: z.ZodUnknown;
+            }, "strip", z.ZodTypeAny, {
+                type: "rules";
+                rules: {
+                    conditions: z.objectOutputType<{
+                        type: z.ZodString;
+                    }, z.ZodTypeAny, "passthrough">[];
+                    value?: unknown;
+                }[];
+                default?: unknown;
+            }, {
+                type: "rules";
+                rules: {
+                    conditions: z.objectInputType<{
+                        type: z.ZodString;
+                    }, z.ZodTypeAny, "passthrough">[];
+                    value?: unknown;
+                }[];
+                default?: unknown;
+            }>, z.ZodObject<{
+                type: z.ZodLiteral<"score">;
+                field: z.ZodString;
+                threshold: z.ZodNumber;
+                above: z.ZodUnknown;
+                below: z.ZodUnknown;
+            }, "strip", z.ZodTypeAny, {
+                type: "score";
+                field: string;
+                threshold: number;
+                above?: unknown;
+                below?: unknown;
+            }, {
+                type: "score";
+                field: string;
+                threshold: number;
+                above?: unknown;
+                below?: unknown;
+            }>, z.ZodObject<{
+                type: z.ZodLiteral<"model">;
+                modelId: z.ZodString;
+                inputs: z.ZodArray<z.ZodString, "many">;
+                outputMapping: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                default: z.ZodUnknown;
+            }, "strip", z.ZodTypeAny, {
+                type: "model";
+                modelId: string;
+                inputs: string[];
+                outputMapping: Record<string, unknown>;
+                default?: unknown;
+            }, {
+                type: "model";
+                modelId: string;
+                inputs: string[];
+                outputMapping: Record<string, unknown>;
+                default?: unknown;
+            }>, z.ZodObject<{
+                type: z.ZodLiteral<"external">;
+                endpoint: z.ZodString;
+                method: z.ZodOptional<z.ZodEnum<["GET", "POST"]>>;
+                default: z.ZodUnknown;
+                timeoutMs: z.ZodOptional<z.ZodNumber>;
+            }, "strip", z.ZodTypeAny, {
+                type: "external";
+                endpoint: string;
+                default?: unknown;
+                method?: "GET" | "POST" | undefined;
+                timeoutMs?: number | undefined;
+            }, {
+                type: "external";
+                endpoint: string;
+                default?: unknown;
+                method?: "GET" | "POST" | undefined;
+                timeoutMs?: number | undefined;
+            }>]>>;
+        }, "strip", z.ZodTypeAny, {
+            routes: {
+                include?: string[] | undefined;
+                exclude?: string[] | undefined;
+            };
+            strategy?: {
+                type: "rules";
+                rules: {
+                    conditions: z.objectOutputType<{
+                        type: z.ZodString;
+                    }, z.ZodTypeAny, "passthrough">[];
+                    value?: unknown;
+                }[];
+                default?: unknown;
+            } | {
+                type: "score";
+                field: string;
+                threshold: number;
+                above?: unknown;
+                below?: unknown;
+            } | {
+                type: "model";
+                modelId: string;
+                inputs: string[];
+                outputMapping: Record<string, unknown>;
+                default?: unknown;
+            } | {
+                type: "external";
+                endpoint: string;
+                default?: unknown;
+                method?: "GET" | "POST" | undefined;
+                timeoutMs?: number | undefined;
+            } | undefined;
+        }, {
+            routes: {
+                include?: string[] | undefined;
+                exclude?: string[] | undefined;
+            };
+            strategy?: {
+                type: "rules";
+                rules: {
+                    conditions: z.objectInputType<{
+                        type: z.ZodString;
+                    }, z.ZodTypeAny, "passthrough">[];
+                    value?: unknown;
+                }[];
+                default?: unknown;
+            } | {
+                type: "score";
+                field: string;
+                threshold: number;
+                above?: unknown;
+                below?: unknown;
+            } | {
+                type: "model";
+                modelId: string;
+                inputs: string[];
+                outputMapping: Record<string, unknown>;
+                default?: unknown;
+            } | {
+                type: "external";
+                endpoint: string;
+                default?: unknown;
+                method?: "GET" | "POST" | undefined;
+                timeoutMs?: number | undefined;
+            } | undefined;
+        }>>;
     }, "strip", z.ZodTypeAny, {
         badgeId: string;
         kind: "gamification:awardBadge";
         anchorId?: string | undefined;
         label?: string | undefined;
+        activation?: {
+            routes: {
+                include?: string[] | undefined;
+                exclude?: string[] | undefined;
+            };
+            strategy?: {
+                type: "rules";
+                rules: {
+                    conditions: z.objectOutputType<{
+                        type: z.ZodString;
+                    }, z.ZodTypeAny, "passthrough">[];
+                    value?: unknown;
+                }[];
+                default?: unknown;
+            } | {
+                type: "score";
+                field: string;
+                threshold: number;
+                above?: unknown;
+                below?: unknown;
+            } | {
+                type: "model";
+                modelId: string;
+                inputs: string[];
+                outputMapping: Record<string, unknown>;
+                default?: unknown;
+            } | {
+                type: "external";
+                endpoint: string;
+                default?: unknown;
+                method?: "GET" | "POST" | undefined;
+                timeoutMs?: number | undefined;
+            } | undefined;
+        } | undefined;
     }, {
         badgeId: string;
         kind: "gamification:awardBadge";
         anchorId?: string | undefined;
         label?: string | undefined;
+        activation?: {
+            routes: {
+                include?: string[] | undefined;
+                exclude?: string[] | undefined;
+            };
+            strategy?: {
+                type: "rules";
+                rules: {
+                    conditions: z.objectInputType<{
+                        type: z.ZodString;
+                    }, z.ZodTypeAny, "passthrough">[];
+                    value?: unknown;
+                }[];
+                default?: unknown;
+            } | {
+                type: "score";
+                field: string;
+                threshold: number;
+                above?: unknown;
+                below?: unknown;
+            } | {
+                type: "model";
+                modelId: string;
+                inputs: string[];
+                outputMapping: Record<string, unknown>;
+                default?: unknown;
+            } | {
+                type: "external";
+                endpoint: string;
+                default?: unknown;
+                method?: "GET" | "POST" | undefined;
+                timeoutMs?: number | undefined;
+            } | undefined;
+        } | undefined;
     }>;
 } | {
     defName: string;
@@ -207,16 +936,259 @@ export declare const actionStepSchemas: ({
         points: z.ZodNumber;
         reason: z.ZodOptional<z.ZodString>;
         label: z.ZodOptional<z.ZodString>;
+    } & {
+        activation: z.ZodOptional<z.ZodObject<{
+            routes: z.ZodObject<{
+                include: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+                exclude: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+            }, "strip", z.ZodTypeAny, {
+                include?: string[] | undefined;
+                exclude?: string[] | undefined;
+            }, {
+                include?: string[] | undefined;
+                exclude?: string[] | undefined;
+            }>;
+            strategy: z.ZodOptional<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+                type: z.ZodLiteral<"rules">;
+                rules: z.ZodArray<z.ZodObject<{
+                    conditions: z.ZodArray<z.ZodObject<{
+                        type: z.ZodString;
+                    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+                        type: z.ZodString;
+                    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+                        type: z.ZodString;
+                    }, z.ZodTypeAny, "passthrough">>, "many">;
+                    value: z.ZodUnknown;
+                }, "strip", z.ZodTypeAny, {
+                    conditions: z.objectOutputType<{
+                        type: z.ZodString;
+                    }, z.ZodTypeAny, "passthrough">[];
+                    value?: unknown;
+                }, {
+                    conditions: z.objectInputType<{
+                        type: z.ZodString;
+                    }, z.ZodTypeAny, "passthrough">[];
+                    value?: unknown;
+                }>, "many">;
+                default: z.ZodUnknown;
+            }, "strip", z.ZodTypeAny, {
+                type: "rules";
+                rules: {
+                    conditions: z.objectOutputType<{
+                        type: z.ZodString;
+                    }, z.ZodTypeAny, "passthrough">[];
+                    value?: unknown;
+                }[];
+                default?: unknown;
+            }, {
+                type: "rules";
+                rules: {
+                    conditions: z.objectInputType<{
+                        type: z.ZodString;
+                    }, z.ZodTypeAny, "passthrough">[];
+                    value?: unknown;
+                }[];
+                default?: unknown;
+            }>, z.ZodObject<{
+                type: z.ZodLiteral<"score">;
+                field: z.ZodString;
+                threshold: z.ZodNumber;
+                above: z.ZodUnknown;
+                below: z.ZodUnknown;
+            }, "strip", z.ZodTypeAny, {
+                type: "score";
+                field: string;
+                threshold: number;
+                above?: unknown;
+                below?: unknown;
+            }, {
+                type: "score";
+                field: string;
+                threshold: number;
+                above?: unknown;
+                below?: unknown;
+            }>, z.ZodObject<{
+                type: z.ZodLiteral<"model">;
+                modelId: z.ZodString;
+                inputs: z.ZodArray<z.ZodString, "many">;
+                outputMapping: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                default: z.ZodUnknown;
+            }, "strip", z.ZodTypeAny, {
+                type: "model";
+                modelId: string;
+                inputs: string[];
+                outputMapping: Record<string, unknown>;
+                default?: unknown;
+            }, {
+                type: "model";
+                modelId: string;
+                inputs: string[];
+                outputMapping: Record<string, unknown>;
+                default?: unknown;
+            }>, z.ZodObject<{
+                type: z.ZodLiteral<"external">;
+                endpoint: z.ZodString;
+                method: z.ZodOptional<z.ZodEnum<["GET", "POST"]>>;
+                default: z.ZodUnknown;
+                timeoutMs: z.ZodOptional<z.ZodNumber>;
+            }, "strip", z.ZodTypeAny, {
+                type: "external";
+                endpoint: string;
+                default?: unknown;
+                method?: "GET" | "POST" | undefined;
+                timeoutMs?: number | undefined;
+            }, {
+                type: "external";
+                endpoint: string;
+                default?: unknown;
+                method?: "GET" | "POST" | undefined;
+                timeoutMs?: number | undefined;
+            }>]>>;
+        }, "strip", z.ZodTypeAny, {
+            routes: {
+                include?: string[] | undefined;
+                exclude?: string[] | undefined;
+            };
+            strategy?: {
+                type: "rules";
+                rules: {
+                    conditions: z.objectOutputType<{
+                        type: z.ZodString;
+                    }, z.ZodTypeAny, "passthrough">[];
+                    value?: unknown;
+                }[];
+                default?: unknown;
+            } | {
+                type: "score";
+                field: string;
+                threshold: number;
+                above?: unknown;
+                below?: unknown;
+            } | {
+                type: "model";
+                modelId: string;
+                inputs: string[];
+                outputMapping: Record<string, unknown>;
+                default?: unknown;
+            } | {
+                type: "external";
+                endpoint: string;
+                default?: unknown;
+                method?: "GET" | "POST" | undefined;
+                timeoutMs?: number | undefined;
+            } | undefined;
+        }, {
+            routes: {
+                include?: string[] | undefined;
+                exclude?: string[] | undefined;
+            };
+            strategy?: {
+                type: "rules";
+                rules: {
+                    conditions: z.objectInputType<{
+                        type: z.ZodString;
+                    }, z.ZodTypeAny, "passthrough">[];
+                    value?: unknown;
+                }[];
+                default?: unknown;
+            } | {
+                type: "score";
+                field: string;
+                threshold: number;
+                above?: unknown;
+                below?: unknown;
+            } | {
+                type: "model";
+                modelId: string;
+                inputs: string[];
+                outputMapping: Record<string, unknown>;
+                default?: unknown;
+            } | {
+                type: "external";
+                endpoint: string;
+                default?: unknown;
+                method?: "GET" | "POST" | undefined;
+                timeoutMs?: number | undefined;
+            } | undefined;
+        }>>;
     }, "strip", z.ZodTypeAny, {
         points: number;
         kind: "gamification:addPoints";
         reason?: string | undefined;
         label?: string | undefined;
+        activation?: {
+            routes: {
+                include?: string[] | undefined;
+                exclude?: string[] | undefined;
+            };
+            strategy?: {
+                type: "rules";
+                rules: {
+                    conditions: z.objectOutputType<{
+                        type: z.ZodString;
+                    }, z.ZodTypeAny, "passthrough">[];
+                    value?: unknown;
+                }[];
+                default?: unknown;
+            } | {
+                type: "score";
+                field: string;
+                threshold: number;
+                above?: unknown;
+                below?: unknown;
+            } | {
+                type: "model";
+                modelId: string;
+                inputs: string[];
+                outputMapping: Record<string, unknown>;
+                default?: unknown;
+            } | {
+                type: "external";
+                endpoint: string;
+                default?: unknown;
+                method?: "GET" | "POST" | undefined;
+                timeoutMs?: number | undefined;
+            } | undefined;
+        } | undefined;
     }, {
         points: number;
         kind: "gamification:addPoints";
         reason?: string | undefined;
         label?: string | undefined;
+        activation?: {
+            routes: {
+                include?: string[] | undefined;
+                exclude?: string[] | undefined;
+            };
+            strategy?: {
+                type: "rules";
+                rules: {
+                    conditions: z.objectInputType<{
+                        type: z.ZodString;
+                    }, z.ZodTypeAny, "passthrough">[];
+                    value?: unknown;
+                }[];
+                default?: unknown;
+            } | {
+                type: "score";
+                field: string;
+                threshold: number;
+                above?: unknown;
+                below?: unknown;
+            } | {
+                type: "model";
+                modelId: string;
+                inputs: string[];
+                outputMapping: Record<string, unknown>;
+                default?: unknown;
+            } | {
+                type: "external";
+                endpoint: string;
+                default?: unknown;
+                method?: "GET" | "POST" | undefined;
+                timeoutMs?: number | undefined;
+            } | undefined;
+        } | undefined;
     }>;
 })[];
 //# sourceMappingURL=schema.d.ts.map

package/dist/schema.d.ts.map CHANGED Viewed

	@@ -1 +1 @@
1	- {"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../src/schema.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;~~AAExB~~;;GAEG;AACH,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAStB,CAAC;AAUH;;GAEG;AACH,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EASvB,CAAC;AAEH,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAC;AAM9D;;GAEG;AACH,eAAO,MAAM,gBAAgB~~;;;;;;;;;;;;;;;EAK3B~~,CAAC;~~AAEH~~;;GAEG;AACH,eAAO,MAAM,eAAe~~;;;;;;;;;;;;;;;EAK1B~~,CAAC;~~AAMH~~;;;;GAIG;AACH,eAAO,MAAM,iBAAiB~~;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;~~IAG7B,CAAC"}
1	+ {"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../src/schema.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAuExB;;GAEG;AACH,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAStB,CAAC;AAUH;;GAEG;AACH,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EASvB,CAAC;AAEH,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAC;AAM9D;;GAEG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAOD,CAAC;AAE7B;;GAEG;AACH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAOA,CAAC;AAM7B;;;;GAIG;AACH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAG7B,CAAC"}

package/dist/schema.js CHANGED Viewed

@@ -4,6 +4,63 @@
  * Zod schema for validating gamification app configuration.
  */
 import { z } from 'zod';
+// ============================================================================
+// Decision Strategy Schema (simplified for this package)
+// ============================================================================
+const ConditionZ = z
+    .object({
+    type: z.string(),
+})
+    .passthrough();
+const RuleZ = z.object({
+    conditions: z.array(ConditionZ),
+    value: z.unknown(),
+});
+const RuleStrategyZ = z.object({
+    type: z.literal('rules'),
+    rules: z.array(RuleZ),
+    default: z.unknown(),
+});
+const ScoreStrategyZ = z.object({
+    type: z.literal('score'),
+    field: z.string(),
+    threshold: z.number(),
+    above: z.unknown(),
+    below: z.unknown(),
+});
+const ModelStrategyZ = z.object({
+    type: z.literal('model'),
+    modelId: z.string(),
+    inputs: z.array(z.string()),
+    outputMapping: z.record(z.unknown()),
+    default: z.unknown(),
+});
+const ExternalStrategyZ = z.object({
+    type: z.literal('external'),
+    endpoint: z.string(),
+    method: z.enum(['GET', 'POST']).optional(),
+    default: z.unknown(),
+    timeoutMs: z.number().optional(),
+});
+const DecisionStrategyZ = z.discriminatedUnion('type', [
+    RuleStrategyZ,
+    ScoreStrategyZ,
+    ModelStrategyZ,
+    ExternalStrategyZ,
+]);
+// ============================================================================
+// Activation Config Schema
+// ============================================================================
+const RouteFilterZ = z.object({
+    include: z.array(z.string()).optional(),
+    exclude: z.array(z.string()).optional(),
+});
+const ActivationConfigZ = z.object({
+    routes: RouteFilterZ,
+    strategy: DecisionStrategyZ.optional(),
+});
+/** Optional activation config — every action can declare its own route scoping */
+const ActionActivationZ = { activation: ActivationConfigZ.optional() };
 /**
  * Badge definition schema.
  */
@@ -43,21 +100,25 @@ export const configSchema = z.object({
 /**
  * Schema for awarding a badge to a user.
  */
-export const AwardBadgeSchema = z.object({
+export const AwardBadgeSchema = z
+    .object({
     kind: z.literal('gamification:awardBadge'),
     badgeId: z.string(),
     anchorId: z.string().optional(),
     label: z.string().optional(),
-});
+})
+    .extend(ActionActivationZ);
 /**
  * Schema for adding points to a user's score.
  */
-export const AddPointsSchema = z.object({
+export const AddPointsSchema = z
+    .object({
     kind: z.literal('gamification:addPoints'),
     points: z.number(),
     reason: z.string().optional(),
     label: z.string().optional(),
-});
+})
+    .extend(ActionActivationZ);
 // ============================================================================
 // Unified Schema Export
 // ============================================================================

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@syntrologie/adapt-gamification",
-  "version": "2.3.0",
+  "version": "2.4.0-canary.10",
   "description": "Adaptive Gamification app - Badges, rewards, points, and engagement mechanics",
   "license": "Proprietary",
   "private": false,
@@ -31,7 +31,9 @@
   "files": [
     "dist"
   ],
+  "bundledDependencies": [],
   "scripts": {
+    "prepack": "node ../../../scripts/prepare-bundled-deps.mjs",
     "build": "tsc",
     "typecheck": "tsc --noEmit",
     "clean": "rm -rf dist",
@@ -43,7 +45,9 @@
     "react-dom": ">=18.0.0",
     "zod": "^3.0.0"
   },
+  "dependencies": {},
   "devDependencies": {
+    "@syntrologie/sdk-contracts": "*",
     "@testing-library/react": "^16.3.2",
     "@types/react": "^19.2.0",
     "jsdom": "^26.1.0",
@@ -52,8 +56,5 @@
     "typescript": "^5.9.3",
     "vitest": "^4.0.18",
     "zod": "^3.25.76"
-  },
-  "dependencies": {
-    "@syntrologie/sdk-contracts": "*"
   }
 }