npm - @syntrologie/adapt-gamification - Versions diffs - 2.4.1 → 2.5.1 - Mend

@syntrologie/adapt-gamification 2.4.1 → 2.5.1

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 (11) hide show

package/dist/schema.d.ts +2420 -800
package/dist/schema.d.ts.map +1 -1
package/dist/schema.js +9 -59
package/dist/types.d.ts +1 -11
package/dist/types.d.ts.map +1 -1
package/package.json +2 -1
package/node_modules/@syntrologie/sdk-contracts/dist/index.d.ts +0 -26
package/node_modules/@syntrologie/sdk-contracts/dist/index.js +0 -13
package/node_modules/@syntrologie/sdk-contracts/dist/schemas.d.ts +0 -1428
package/node_modules/@syntrologie/sdk-contracts/dist/schemas.js +0 -142
package/node_modules/@syntrologie/sdk-contracts/package.json +0 -33

package/dist/schema.d.ts CHANGED Viewed

@@ -148,55 +148,1771 @@ export declare const AwardBadgeSchema: z.ZodObject<{
     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">>;
+    triggerWhen: z.ZodOptional<z.ZodNullable<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+        type: z.ZodLiteral<"rules">;
+        rules: z.ZodArray<z.ZodObject<{
+            conditions: z.ZodArray<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+                type: z.ZodLiteral<"page_url">;
+                url: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                type: "page_url";
+                url: string;
+            }, {
+                type: "page_url";
+                url: string;
+            }>, z.ZodObject<{
+                type: z.ZodLiteral<"route">;
+                routeId: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                type: "route";
+                routeId: string;
+            }, {
+                type: "route";
+                routeId: string;
+            }>, z.ZodObject<{
+                type: z.ZodLiteral<"anchor_visible">;
+                anchorId: z.ZodString;
+                state: z.ZodEnum<["visible", "present", "absent"]>;
+            }, "strip", z.ZodTypeAny, {
+                type: "anchor_visible";
+                anchorId: string;
+                state: "visible" | "present" | "absent";
+            }, {
+                type: "anchor_visible";
+                anchorId: string;
+                state: "visible" | "present" | "absent";
+            }>, z.ZodObject<{
+                type: z.ZodLiteral<"event_occurred">;
+                eventName: z.ZodString;
+                withinMs: z.ZodOptional<z.ZodNumber>;
+            }, "strip", z.ZodTypeAny, {
+                type: "event_occurred";
+                eventName: string;
+                withinMs?: number | undefined;
+            }, {
+                type: "event_occurred";
+                eventName: string;
+                withinMs?: number | undefined;
+            }>, z.ZodObject<{
+                type: z.ZodLiteral<"state_equals">;
+                key: z.ZodString;
+                value: z.ZodUnknown;
+            }, "strip", z.ZodTypeAny, {
+                type: "state_equals";
+                key: string;
+                value?: unknown;
+            }, {
+                type: "state_equals";
+                key: string;
+                value?: unknown;
+            }>, z.ZodObject<{
+                type: z.ZodLiteral<"viewport">;
+                minWidth: z.ZodOptional<z.ZodNumber>;
+                maxWidth: z.ZodOptional<z.ZodNumber>;
+                minHeight: z.ZodOptional<z.ZodNumber>;
+                maxHeight: z.ZodOptional<z.ZodNumber>;
+            }, "strip", z.ZodTypeAny, {
+                type: "viewport";
+                minWidth?: number | undefined;
+                maxWidth?: number | undefined;
+                minHeight?: number | undefined;
+                maxHeight?: number | undefined;
+            }, {
+                type: "viewport";
+                minWidth?: number | undefined;
+                maxWidth?: number | undefined;
+                minHeight?: number | undefined;
+                maxHeight?: number | undefined;
+            }>, z.ZodObject<{
+                type: z.ZodLiteral<"session_metric">;
+                key: z.ZodString;
+                operator: z.ZodEnum<["gte", "lte", "eq", "gt", "lt"]>;
+                threshold: z.ZodNumber;
+            }, "strip", z.ZodTypeAny, {
+                type: "session_metric";
+                key: string;
+                operator: "gte" | "lte" | "eq" | "gt" | "lt";
+                threshold: number;
+            }, {
+                type: "session_metric";
+                key: string;
+                operator: "gte" | "lte" | "eq" | "gt" | "lt";
+                threshold: number;
+            }>, z.ZodObject<{
+                type: z.ZodLiteral<"dismissed">;
+                key: z.ZodString;
+                inverted: z.ZodOptional<z.ZodBoolean>;
+            }, "strip", z.ZodTypeAny, {
+                type: "dismissed";
+                key: string;
+                inverted?: boolean | undefined;
+            }, {
+                type: "dismissed";
+                key: string;
+                inverted?: boolean | undefined;
+            }>, z.ZodObject<{
+                type: z.ZodLiteral<"cooldown_active">;
+                key: z.ZodString;
+                inverted: z.ZodOptional<z.ZodBoolean>;
+            }, "strip", z.ZodTypeAny, {
+                type: "cooldown_active";
+                key: string;
+                inverted?: boolean | undefined;
+            }, {
+                type: "cooldown_active";
+                key: string;
+                inverted?: boolean | undefined;
+            }>, z.ZodObject<{
+                type: z.ZodLiteral<"frequency_limit">;
+                key: z.ZodString;
+                limit: z.ZodNumber;
+                inverted: z.ZodOptional<z.ZodBoolean>;
+            }, "strip", z.ZodTypeAny, {
+                type: "frequency_limit";
+                key: string;
+                limit: number;
+                inverted?: boolean | undefined;
+            }, {
+                type: "frequency_limit";
+                key: string;
+                limit: number;
+                inverted?: boolean | undefined;
+            }>, z.ZodObject<{
+                type: z.ZodLiteral<"event_count">;
+                key: z.ZodString;
+                operator: z.ZodEnum<["gte", "lte", "eq", "gt", "lt"]>;
+                count: z.ZodNumber;
+                withinMs: z.ZodOptional<z.ZodNumber>;
+                counter: z.ZodOptional<z.ZodObject<{
+                    events: z.ZodArray<z.ZodString, "many">;
+                    match: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+                        equals: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+                        contains: z.ZodOptional<z.ZodString>;
+                    }, "strip", z.ZodTypeAny, {
+                        equals?: string | number | boolean | undefined;
+                        contains?: string | undefined;
+                    }, {
+                        equals?: string | number | boolean | undefined;
+                        contains?: string | undefined;
+                    }>>>;
+                }, "strip", z.ZodTypeAny, {
+                    events: string[];
+                    match?: Record<string, {
+                        equals?: string | number | boolean | undefined;
+                        contains?: string | undefined;
+                    }> | undefined;
+                }, {
+                    events: string[];
+                    match?: Record<string, {
+                        equals?: string | number | boolean | undefined;
+                        contains?: string | undefined;
+                    }> | undefined;
+                }>>;
+            }, "strip", z.ZodTypeAny, {
+                type: "event_count";
+                key: string;
+                operator: "gte" | "lte" | "eq" | "gt" | "lt";
+                count: number;
+                withinMs?: number | undefined;
+                counter?: {
+                    events: string[];
+                    match?: Record<string, {
+                        equals?: string | number | boolean | undefined;
+                        contains?: string | undefined;
+                    }> | undefined;
+                } | undefined;
+            }, {
+                type: "event_count";
+                key: string;
+                operator: "gte" | "lte" | "eq" | "gt" | "lt";
+                count: number;
+                withinMs?: number | undefined;
+                counter?: {
+                    events: string[];
+                    match?: Record<string, {
+                        equals?: string | number | boolean | undefined;
+                        contains?: string | undefined;
+                    }> | undefined;
+                } | undefined;
+            }>]>, "many">;
+            value: z.ZodUnknown;
         }, "strip", z.ZodTypeAny, {
-            include?: string[] | undefined;
-            exclude?: string[] | undefined;
+            conditions: ({
+                type: "page_url";
+                url: string;
+            } | {
+                type: "route";
+                routeId: string;
+            } | {
+                type: "anchor_visible";
+                anchorId: string;
+                state: "visible" | "present" | "absent";
+            } | {
+                type: "event_occurred";
+                eventName: string;
+                withinMs?: number | undefined;
+            } | {
+                type: "state_equals";
+                key: string;
+                value?: unknown;
+            } | {
+                type: "viewport";
+                minWidth?: number | undefined;
+                maxWidth?: number | undefined;
+                minHeight?: number | undefined;
+                maxHeight?: number | undefined;
+            } | {
+                type: "session_metric";
+                key: string;
+                operator: "gte" | "lte" | "eq" | "gt" | "lt";
+                threshold: number;
+            } | {
+                type: "dismissed";
+                key: string;
+                inverted?: boolean | undefined;
+            } | {
+                type: "cooldown_active";
+                key: string;
+                inverted?: boolean | undefined;
+            } | {
+                type: "frequency_limit";
+                key: string;
+                limit: number;
+                inverted?: boolean | undefined;
+            } | {
+                type: "event_count";
+                key: string;
+                operator: "gte" | "lte" | "eq" | "gt" | "lt";
+                count: number;
+                withinMs?: number | undefined;
+                counter?: {
+                    events: string[];
+                    match?: Record<string, {
+                        equals?: string | number | boolean | undefined;
+                        contains?: string | undefined;
+                    }> | undefined;
+                } | undefined;
+            })[];
+            value?: unknown;
         }, {
-            include?: string[] | undefined;
-            exclude?: string[] | undefined;
-        }>;
-        strategy: z.ZodOptional<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+            conditions: ({
+                type: "page_url";
+                url: string;
+            } | {
+                type: "route";
+                routeId: string;
+            } | {
+                type: "anchor_visible";
+                anchorId: string;
+                state: "visible" | "present" | "absent";
+            } | {
+                type: "event_occurred";
+                eventName: string;
+                withinMs?: number | undefined;
+            } | {
+                type: "state_equals";
+                key: string;
+                value?: unknown;
+            } | {
+                type: "viewport";
+                minWidth?: number | undefined;
+                maxWidth?: number | undefined;
+                minHeight?: number | undefined;
+                maxHeight?: number | undefined;
+            } | {
+                type: "session_metric";
+                key: string;
+                operator: "gte" | "lte" | "eq" | "gt" | "lt";
+                threshold: number;
+            } | {
+                type: "dismissed";
+                key: string;
+                inverted?: boolean | undefined;
+            } | {
+                type: "cooldown_active";
+                key: string;
+                inverted?: boolean | undefined;
+            } | {
+                type: "frequency_limit";
+                key: string;
+                limit: number;
+                inverted?: boolean | undefined;
+            } | {
+                type: "event_count";
+                key: string;
+                operator: "gte" | "lte" | "eq" | "gt" | "lt";
+                count: number;
+                withinMs?: number | undefined;
+                counter?: {
+                    events: string[];
+                    match?: Record<string, {
+                        equals?: string | number | boolean | undefined;
+                        contains?: string | undefined;
+                    }> | undefined;
+                } | undefined;
+            })[];
+            value?: unknown;
+        }>, "many">;
+        default: z.ZodUnknown;
+    }, "strip", z.ZodTypeAny, {
+        type: "rules";
+        rules: {
+            conditions: ({
+                type: "page_url";
+                url: string;
+            } | {
+                type: "route";
+                routeId: string;
+            } | {
+                type: "anchor_visible";
+                anchorId: string;
+                state: "visible" | "present" | "absent";
+            } | {
+                type: "event_occurred";
+                eventName: string;
+                withinMs?: number | undefined;
+            } | {
+                type: "state_equals";
+                key: string;
+                value?: unknown;
+            } | {
+                type: "viewport";
+                minWidth?: number | undefined;
+                maxWidth?: number | undefined;
+                minHeight?: number | undefined;
+                maxHeight?: number | undefined;
+            } | {
+                type: "session_metric";
+                key: string;
+                operator: "gte" | "lte" | "eq" | "gt" | "lt";
+                threshold: number;
+            } | {
+                type: "dismissed";
+                key: string;
+                inverted?: boolean | undefined;
+            } | {
+                type: "cooldown_active";
+                key: string;
+                inverted?: boolean | undefined;
+            } | {
+                type: "frequency_limit";
+                key: string;
+                limit: number;
+                inverted?: boolean | undefined;
+            } | {
+                type: "event_count";
+                key: string;
+                operator: "gte" | "lte" | "eq" | "gt" | "lt";
+                count: number;
+                withinMs?: number | undefined;
+                counter?: {
+                    events: string[];
+                    match?: Record<string, {
+                        equals?: string | number | boolean | undefined;
+                        contains?: string | undefined;
+                    }> | undefined;
+                } | undefined;
+            })[];
+            value?: unknown;
+        }[];
+        default?: unknown;
+    }, {
+        type: "rules";
+        rules: {
+            conditions: ({
+                type: "page_url";
+                url: string;
+            } | {
+                type: "route";
+                routeId: string;
+            } | {
+                type: "anchor_visible";
+                anchorId: string;
+                state: "visible" | "present" | "absent";
+            } | {
+                type: "event_occurred";
+                eventName: string;
+                withinMs?: number | undefined;
+            } | {
+                type: "state_equals";
+                key: string;
+                value?: unknown;
+            } | {
+                type: "viewport";
+                minWidth?: number | undefined;
+                maxWidth?: number | undefined;
+                minHeight?: number | undefined;
+                maxHeight?: number | undefined;
+            } | {
+                type: "session_metric";
+                key: string;
+                operator: "gte" | "lte" | "eq" | "gt" | "lt";
+                threshold: number;
+            } | {
+                type: "dismissed";
+                key: string;
+                inverted?: boolean | undefined;
+            } | {
+                type: "cooldown_active";
+                key: string;
+                inverted?: boolean | undefined;
+            } | {
+                type: "frequency_limit";
+                key: string;
+                limit: number;
+                inverted?: boolean | undefined;
+            } | {
+                type: "event_count";
+                key: string;
+                operator: "gte" | "lte" | "eq" | "gt" | "lt";
+                count: number;
+                withinMs?: number | undefined;
+                counter?: {
+                    events: string[];
+                    match?: Record<string, {
+                        equals?: string | number | boolean | undefined;
+                        contains?: string | undefined;
+                    }> | undefined;
+                } | undefined;
+            })[];
+            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";
+        threshold: number;
+        field: string;
+        above?: unknown;
+        below?: unknown;
+    }, {
+        type: "score";
+        threshold: number;
+        field: string;
+        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, {
+    badgeId: string;
+    kind: "gamification:awardBadge";
+    anchorId?: string | undefined;
+    label?: string | undefined;
+    triggerWhen?: {
+        type: "rules";
+        rules: {
+            conditions: ({
+                type: "page_url";
+                url: string;
+            } | {
+                type: "route";
+                routeId: string;
+            } | {
+                type: "anchor_visible";
+                anchorId: string;
+                state: "visible" | "present" | "absent";
+            } | {
+                type: "event_occurred";
+                eventName: string;
+                withinMs?: number | undefined;
+            } | {
+                type: "state_equals";
+                key: string;
+                value?: unknown;
+            } | {
+                type: "viewport";
+                minWidth?: number | undefined;
+                maxWidth?: number | undefined;
+                minHeight?: number | undefined;
+                maxHeight?: number | undefined;
+            } | {
+                type: "session_metric";
+                key: string;
+                operator: "gte" | "lte" | "eq" | "gt" | "lt";
+                threshold: number;
+            } | {
+                type: "dismissed";
+                key: string;
+                inverted?: boolean | undefined;
+            } | {
+                type: "cooldown_active";
+                key: string;
+                inverted?: boolean | undefined;
+            } | {
+                type: "frequency_limit";
+                key: string;
+                limit: number;
+                inverted?: boolean | undefined;
+            } | {
+                type: "event_count";
+                key: string;
+                operator: "gte" | "lte" | "eq" | "gt" | "lt";
+                count: number;
+                withinMs?: number | undefined;
+                counter?: {
+                    events: string[];
+                    match?: Record<string, {
+                        equals?: string | number | boolean | undefined;
+                        contains?: string | undefined;
+                    }> | undefined;
+                } | undefined;
+            })[];
+            value?: unknown;
+        }[];
+        default?: unknown;
+    } | {
+        type: "score";
+        threshold: number;
+        field: string;
+        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;
+    } | null | undefined;
+}, {
+    badgeId: string;
+    kind: "gamification:awardBadge";
+    anchorId?: string | undefined;
+    label?: string | undefined;
+    triggerWhen?: {
+        type: "rules";
+        rules: {
+            conditions: ({
+                type: "page_url";
+                url: string;
+            } | {
+                type: "route";
+                routeId: string;
+            } | {
+                type: "anchor_visible";
+                anchorId: string;
+                state: "visible" | "present" | "absent";
+            } | {
+                type: "event_occurred";
+                eventName: string;
+                withinMs?: number | undefined;
+            } | {
+                type: "state_equals";
+                key: string;
+                value?: unknown;
+            } | {
+                type: "viewport";
+                minWidth?: number | undefined;
+                maxWidth?: number | undefined;
+                minHeight?: number | undefined;
+                maxHeight?: number | undefined;
+            } | {
+                type: "session_metric";
+                key: string;
+                operator: "gte" | "lte" | "eq" | "gt" | "lt";
+                threshold: number;
+            } | {
+                type: "dismissed";
+                key: string;
+                inverted?: boolean | undefined;
+            } | {
+                type: "cooldown_active";
+                key: string;
+                inverted?: boolean | undefined;
+            } | {
+                type: "frequency_limit";
+                key: string;
+                limit: number;
+                inverted?: boolean | undefined;
+            } | {
+                type: "event_count";
+                key: string;
+                operator: "gte" | "lte" | "eq" | "gt" | "lt";
+                count: number;
+                withinMs?: number | undefined;
+                counter?: {
+                    events: string[];
+                    match?: Record<string, {
+                        equals?: string | number | boolean | undefined;
+                        contains?: string | undefined;
+                    }> | undefined;
+                } | undefined;
+            })[];
+            value?: unknown;
+        }[];
+        default?: unknown;
+    } | {
+        type: "score";
+        threshold: number;
+        field: string;
+        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;
+    } | null | undefined;
+}>;
+/**
+ * Schema for adding points to a user's score.
+ */
+export declare const AddPointsSchema: z.ZodObject<{
+    kind: z.ZodLiteral<"gamification:addPoints">;
+    points: z.ZodNumber;
+    reason: z.ZodOptional<z.ZodString>;
+    label: z.ZodOptional<z.ZodString>;
+} & {
+    triggerWhen: z.ZodOptional<z.ZodNullable<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+        type: z.ZodLiteral<"rules">;
+        rules: z.ZodArray<z.ZodObject<{
+            conditions: z.ZodArray<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+                type: z.ZodLiteral<"page_url">;
+                url: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                type: "page_url";
+                url: string;
+            }, {
+                type: "page_url";
+                url: string;
+            }>, z.ZodObject<{
+                type: z.ZodLiteral<"route">;
+                routeId: z.ZodString;
+            }, "strip", z.ZodTypeAny, {
+                type: "route";
+                routeId: string;
+            }, {
+                type: "route";
+                routeId: string;
+            }>, z.ZodObject<{
+                type: z.ZodLiteral<"anchor_visible">;
+                anchorId: z.ZodString;
+                state: z.ZodEnum<["visible", "present", "absent"]>;
+            }, "strip", z.ZodTypeAny, {
+                type: "anchor_visible";
+                anchorId: string;
+                state: "visible" | "present" | "absent";
+            }, {
+                type: "anchor_visible";
+                anchorId: string;
+                state: "visible" | "present" | "absent";
+            }>, z.ZodObject<{
+                type: z.ZodLiteral<"event_occurred">;
+                eventName: z.ZodString;
+                withinMs: z.ZodOptional<z.ZodNumber>;
+            }, "strip", z.ZodTypeAny, {
+                type: "event_occurred";
+                eventName: string;
+                withinMs?: number | undefined;
+            }, {
+                type: "event_occurred";
+                eventName: string;
+                withinMs?: number | undefined;
+            }>, z.ZodObject<{
+                type: z.ZodLiteral<"state_equals">;
+                key: z.ZodString;
+                value: z.ZodUnknown;
+            }, "strip", z.ZodTypeAny, {
+                type: "state_equals";
+                key: string;
+                value?: unknown;
+            }, {
+                type: "state_equals";
+                key: string;
+                value?: unknown;
+            }>, z.ZodObject<{
+                type: z.ZodLiteral<"viewport">;
+                minWidth: z.ZodOptional<z.ZodNumber>;
+                maxWidth: z.ZodOptional<z.ZodNumber>;
+                minHeight: z.ZodOptional<z.ZodNumber>;
+                maxHeight: z.ZodOptional<z.ZodNumber>;
+            }, "strip", z.ZodTypeAny, {
+                type: "viewport";
+                minWidth?: number | undefined;
+                maxWidth?: number | undefined;
+                minHeight?: number | undefined;
+                maxHeight?: number | undefined;
+            }, {
+                type: "viewport";
+                minWidth?: number | undefined;
+                maxWidth?: number | undefined;
+                minHeight?: number | undefined;
+                maxHeight?: number | undefined;
+            }>, z.ZodObject<{
+                type: z.ZodLiteral<"session_metric">;
+                key: z.ZodString;
+                operator: z.ZodEnum<["gte", "lte", "eq", "gt", "lt"]>;
+                threshold: z.ZodNumber;
+            }, "strip", z.ZodTypeAny, {
+                type: "session_metric";
+                key: string;
+                operator: "gte" | "lte" | "eq" | "gt" | "lt";
+                threshold: number;
+            }, {
+                type: "session_metric";
+                key: string;
+                operator: "gte" | "lte" | "eq" | "gt" | "lt";
+                threshold: number;
+            }>, z.ZodObject<{
+                type: z.ZodLiteral<"dismissed">;
+                key: z.ZodString;
+                inverted: z.ZodOptional<z.ZodBoolean>;
+            }, "strip", z.ZodTypeAny, {
+                type: "dismissed";
+                key: string;
+                inverted?: boolean | undefined;
+            }, {
+                type: "dismissed";
+                key: string;
+                inverted?: boolean | undefined;
+            }>, z.ZodObject<{
+                type: z.ZodLiteral<"cooldown_active">;
+                key: z.ZodString;
+                inverted: z.ZodOptional<z.ZodBoolean>;
+            }, "strip", z.ZodTypeAny, {
+                type: "cooldown_active";
+                key: string;
+                inverted?: boolean | undefined;
+            }, {
+                type: "cooldown_active";
+                key: string;
+                inverted?: boolean | undefined;
+            }>, z.ZodObject<{
+                type: z.ZodLiteral<"frequency_limit">;
+                key: z.ZodString;
+                limit: z.ZodNumber;
+                inverted: z.ZodOptional<z.ZodBoolean>;
+            }, "strip", z.ZodTypeAny, {
+                type: "frequency_limit";
+                key: string;
+                limit: number;
+                inverted?: boolean | undefined;
+            }, {
+                type: "frequency_limit";
+                key: string;
+                limit: number;
+                inverted?: boolean | undefined;
+            }>, z.ZodObject<{
+                type: z.ZodLiteral<"event_count">;
+                key: z.ZodString;
+                operator: z.ZodEnum<["gte", "lte", "eq", "gt", "lt"]>;
+                count: z.ZodNumber;
+                withinMs: z.ZodOptional<z.ZodNumber>;
+                counter: z.ZodOptional<z.ZodObject<{
+                    events: z.ZodArray<z.ZodString, "many">;
+                    match: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+                        equals: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+                        contains: z.ZodOptional<z.ZodString>;
+                    }, "strip", z.ZodTypeAny, {
+                        equals?: string | number | boolean | undefined;
+                        contains?: string | undefined;
+                    }, {
+                        equals?: string | number | boolean | undefined;
+                        contains?: string | undefined;
+                    }>>>;
+                }, "strip", z.ZodTypeAny, {
+                    events: string[];
+                    match?: Record<string, {
+                        equals?: string | number | boolean | undefined;
+                        contains?: string | undefined;
+                    }> | undefined;
+                }, {
+                    events: string[];
+                    match?: Record<string, {
+                        equals?: string | number | boolean | undefined;
+                        contains?: string | undefined;
+                    }> | undefined;
+                }>>;
+            }, "strip", z.ZodTypeAny, {
+                type: "event_count";
+                key: string;
+                operator: "gte" | "lte" | "eq" | "gt" | "lt";
+                count: number;
+                withinMs?: number | undefined;
+                counter?: {
+                    events: string[];
+                    match?: Record<string, {
+                        equals?: string | number | boolean | undefined;
+                        contains?: string | undefined;
+                    }> | undefined;
+                } | undefined;
+            }, {
+                type: "event_count";
+                key: string;
+                operator: "gte" | "lte" | "eq" | "gt" | "lt";
+                count: number;
+                withinMs?: number | undefined;
+                counter?: {
+                    events: string[];
+                    match?: Record<string, {
+                        equals?: string | number | boolean | undefined;
+                        contains?: string | undefined;
+                    }> | undefined;
+                } | undefined;
+            }>]>, "many">;
+            value: z.ZodUnknown;
+        }, "strip", z.ZodTypeAny, {
+            conditions: ({
+                type: "page_url";
+                url: string;
+            } | {
+                type: "route";
+                routeId: string;
+            } | {
+                type: "anchor_visible";
+                anchorId: string;
+                state: "visible" | "present" | "absent";
+            } | {
+                type: "event_occurred";
+                eventName: string;
+                withinMs?: number | undefined;
+            } | {
+                type: "state_equals";
+                key: string;
+                value?: unknown;
+            } | {
+                type: "viewport";
+                minWidth?: number | undefined;
+                maxWidth?: number | undefined;
+                minHeight?: number | undefined;
+                maxHeight?: number | undefined;
+            } | {
+                type: "session_metric";
+                key: string;
+                operator: "gte" | "lte" | "eq" | "gt" | "lt";
+                threshold: number;
+            } | {
+                type: "dismissed";
+                key: string;
+                inverted?: boolean | undefined;
+            } | {
+                type: "cooldown_active";
+                key: string;
+                inverted?: boolean | undefined;
+            } | {
+                type: "frequency_limit";
+                key: string;
+                limit: number;
+                inverted?: boolean | undefined;
+            } | {
+                type: "event_count";
+                key: string;
+                operator: "gte" | "lte" | "eq" | "gt" | "lt";
+                count: number;
+                withinMs?: number | undefined;
+                counter?: {
+                    events: string[];
+                    match?: Record<string, {
+                        equals?: string | number | boolean | undefined;
+                        contains?: string | undefined;
+                    }> | undefined;
+                } | undefined;
+            })[];
+            value?: unknown;
+        }, {
+            conditions: ({
+                type: "page_url";
+                url: string;
+            } | {
+                type: "route";
+                routeId: string;
+            } | {
+                type: "anchor_visible";
+                anchorId: string;
+                state: "visible" | "present" | "absent";
+            } | {
+                type: "event_occurred";
+                eventName: string;
+                withinMs?: number | undefined;
+            } | {
+                type: "state_equals";
+                key: string;
+                value?: unknown;
+            } | {
+                type: "viewport";
+                minWidth?: number | undefined;
+                maxWidth?: number | undefined;
+                minHeight?: number | undefined;
+                maxHeight?: number | undefined;
+            } | {
+                type: "session_metric";
+                key: string;
+                operator: "gte" | "lte" | "eq" | "gt" | "lt";
+                threshold: number;
+            } | {
+                type: "dismissed";
+                key: string;
+                inverted?: boolean | undefined;
+            } | {
+                type: "cooldown_active";
+                key: string;
+                inverted?: boolean | undefined;
+            } | {
+                type: "frequency_limit";
+                key: string;
+                limit: number;
+                inverted?: boolean | undefined;
+            } | {
+                type: "event_count";
+                key: string;
+                operator: "gte" | "lte" | "eq" | "gt" | "lt";
+                count: number;
+                withinMs?: number | undefined;
+                counter?: {
+                    events: string[];
+                    match?: Record<string, {
+                        equals?: string | number | boolean | undefined;
+                        contains?: string | undefined;
+                    }> | undefined;
+                } | undefined;
+            })[];
+            value?: unknown;
+        }>, "many">;
+        default: z.ZodUnknown;
+    }, "strip", z.ZodTypeAny, {
+        type: "rules";
+        rules: {
+            conditions: ({
+                type: "page_url";
+                url: string;
+            } | {
+                type: "route";
+                routeId: string;
+            } | {
+                type: "anchor_visible";
+                anchorId: string;
+                state: "visible" | "present" | "absent";
+            } | {
+                type: "event_occurred";
+                eventName: string;
+                withinMs?: number | undefined;
+            } | {
+                type: "state_equals";
+                key: string;
+                value?: unknown;
+            } | {
+                type: "viewport";
+                minWidth?: number | undefined;
+                maxWidth?: number | undefined;
+                minHeight?: number | undefined;
+                maxHeight?: number | undefined;
+            } | {
+                type: "session_metric";
+                key: string;
+                operator: "gte" | "lte" | "eq" | "gt" | "lt";
+                threshold: number;
+            } | {
+                type: "dismissed";
+                key: string;
+                inverted?: boolean | undefined;
+            } | {
+                type: "cooldown_active";
+                key: string;
+                inverted?: boolean | undefined;
+            } | {
+                type: "frequency_limit";
+                key: string;
+                limit: number;
+                inverted?: boolean | undefined;
+            } | {
+                type: "event_count";
+                key: string;
+                operator: "gte" | "lte" | "eq" | "gt" | "lt";
+                count: number;
+                withinMs?: number | undefined;
+                counter?: {
+                    events: string[];
+                    match?: Record<string, {
+                        equals?: string | number | boolean | undefined;
+                        contains?: string | undefined;
+                    }> | undefined;
+                } | undefined;
+            })[];
+            value?: unknown;
+        }[];
+        default?: unknown;
+    }, {
+        type: "rules";
+        rules: {
+            conditions: ({
+                type: "page_url";
+                url: string;
+            } | {
+                type: "route";
+                routeId: string;
+            } | {
+                type: "anchor_visible";
+                anchorId: string;
+                state: "visible" | "present" | "absent";
+            } | {
+                type: "event_occurred";
+                eventName: string;
+                withinMs?: number | undefined;
+            } | {
+                type: "state_equals";
+                key: string;
+                value?: unknown;
+            } | {
+                type: "viewport";
+                minWidth?: number | undefined;
+                maxWidth?: number | undefined;
+                minHeight?: number | undefined;
+                maxHeight?: number | undefined;
+            } | {
+                type: "session_metric";
+                key: string;
+                operator: "gte" | "lte" | "eq" | "gt" | "lt";
+                threshold: number;
+            } | {
+                type: "dismissed";
+                key: string;
+                inverted?: boolean | undefined;
+            } | {
+                type: "cooldown_active";
+                key: string;
+                inverted?: boolean | undefined;
+            } | {
+                type: "frequency_limit";
+                key: string;
+                limit: number;
+                inverted?: boolean | undefined;
+            } | {
+                type: "event_count";
+                key: string;
+                operator: "gte" | "lte" | "eq" | "gt" | "lt";
+                count: number;
+                withinMs?: number | undefined;
+                counter?: {
+                    events: string[];
+                    match?: Record<string, {
+                        equals?: string | number | boolean | undefined;
+                        contains?: string | undefined;
+                    }> | undefined;
+                } | undefined;
+            })[];
+            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";
+        threshold: number;
+        field: string;
+        above?: unknown;
+        below?: unknown;
+    }, {
+        type: "score";
+        threshold: number;
+        field: string;
+        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, {
+    points: number;
+    kind: "gamification:addPoints";
+    reason?: string | undefined;
+    label?: string | undefined;
+    triggerWhen?: {
+        type: "rules";
+        rules: {
+            conditions: ({
+                type: "page_url";
+                url: string;
+            } | {
+                type: "route";
+                routeId: string;
+            } | {
+                type: "anchor_visible";
+                anchorId: string;
+                state: "visible" | "present" | "absent";
+            } | {
+                type: "event_occurred";
+                eventName: string;
+                withinMs?: number | undefined;
+            } | {
+                type: "state_equals";
+                key: string;
+                value?: unknown;
+            } | {
+                type: "viewport";
+                minWidth?: number | undefined;
+                maxWidth?: number | undefined;
+                minHeight?: number | undefined;
+                maxHeight?: number | undefined;
+            } | {
+                type: "session_metric";
+                key: string;
+                operator: "gte" | "lte" | "eq" | "gt" | "lt";
+                threshold: number;
+            } | {
+                type: "dismissed";
+                key: string;
+                inverted?: boolean | undefined;
+            } | {
+                type: "cooldown_active";
+                key: string;
+                inverted?: boolean | undefined;
+            } | {
+                type: "frequency_limit";
+                key: string;
+                limit: number;
+                inverted?: boolean | undefined;
+            } | {
+                type: "event_count";
+                key: string;
+                operator: "gte" | "lte" | "eq" | "gt" | "lt";
+                count: number;
+                withinMs?: number | undefined;
+                counter?: {
+                    events: string[];
+                    match?: Record<string, {
+                        equals?: string | number | boolean | undefined;
+                        contains?: string | undefined;
+                    }> | undefined;
+                } | undefined;
+            })[];
+            value?: unknown;
+        }[];
+        default?: unknown;
+    } | {
+        type: "score";
+        threshold: number;
+        field: string;
+        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;
+    } | null | undefined;
+}, {
+    points: number;
+    kind: "gamification:addPoints";
+    reason?: string | undefined;
+    label?: string | undefined;
+    triggerWhen?: {
+        type: "rules";
+        rules: {
+            conditions: ({
+                type: "page_url";
+                url: string;
+            } | {
+                type: "route";
+                routeId: string;
+            } | {
+                type: "anchor_visible";
+                anchorId: string;
+                state: "visible" | "present" | "absent";
+            } | {
+                type: "event_occurred";
+                eventName: string;
+                withinMs?: number | undefined;
+            } | {
+                type: "state_equals";
+                key: string;
+                value?: unknown;
+            } | {
+                type: "viewport";
+                minWidth?: number | undefined;
+                maxWidth?: number | undefined;
+                minHeight?: number | undefined;
+                maxHeight?: number | undefined;
+            } | {
+                type: "session_metric";
+                key: string;
+                operator: "gte" | "lte" | "eq" | "gt" | "lt";
+                threshold: number;
+            } | {
+                type: "dismissed";
+                key: string;
+                inverted?: boolean | undefined;
+            } | {
+                type: "cooldown_active";
+                key: string;
+                inverted?: boolean | undefined;
+            } | {
+                type: "frequency_limit";
+                key: string;
+                limit: number;
+                inverted?: boolean | undefined;
+            } | {
+                type: "event_count";
+                key: string;
+                operator: "gte" | "lte" | "eq" | "gt" | "lt";
+                count: number;
+                withinMs?: number | undefined;
+                counter?: {
+                    events: string[];
+                    match?: Record<string, {
+                        equals?: string | number | boolean | undefined;
+                        contains?: string | undefined;
+                    }> | undefined;
+                } | undefined;
+            })[];
+            value?: unknown;
+        }[];
+        default?: unknown;
+    } | {
+        type: "score";
+        threshold: number;
+        field: string;
+        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;
+    } | null | undefined;
+}>;
+/**
+ * Action step schemas for unified JSON Schema generation.
+ * The build script reads this array to merge adaptive actions into the
+ * unified canvas-config.schema.json.
+ */
+export declare const actionStepSchemas: ({
+    defName: string;
+    schema: z.ZodObject<{
+        kind: z.ZodLiteral<"gamification:awardBadge">;
+        badgeId: z.ZodString;
+        anchorId: z.ZodOptional<z.ZodString>;
+        label: z.ZodOptional<z.ZodString>;
+    } & {
+        triggerWhen: z.ZodOptional<z.ZodNullable<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">;
+                conditions: z.ZodArray<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+                    type: z.ZodLiteral<"page_url">;
+                    url: z.ZodString;
+                }, "strip", z.ZodTypeAny, {
+                    type: "page_url";
+                    url: string;
+                }, {
+                    type: "page_url";
+                    url: string;
+                }>, z.ZodObject<{
+                    type: z.ZodLiteral<"route">;
+                    routeId: z.ZodString;
+                }, "strip", z.ZodTypeAny, {
+                    type: "route";
+                    routeId: string;
+                }, {
+                    type: "route";
+                    routeId: string;
+                }>, z.ZodObject<{
+                    type: z.ZodLiteral<"anchor_visible">;
+                    anchorId: z.ZodString;
+                    state: z.ZodEnum<["visible", "present", "absent"]>;
+                }, "strip", z.ZodTypeAny, {
+                    type: "anchor_visible";
+                    anchorId: string;
+                    state: "visible" | "present" | "absent";
+                }, {
+                    type: "anchor_visible";
+                    anchorId: string;
+                    state: "visible" | "present" | "absent";
+                }>, z.ZodObject<{
+                    type: z.ZodLiteral<"event_occurred">;
+                    eventName: z.ZodString;
+                    withinMs: z.ZodOptional<z.ZodNumber>;
+                }, "strip", z.ZodTypeAny, {
+                    type: "event_occurred";
+                    eventName: string;
+                    withinMs?: number | undefined;
+                }, {
+                    type: "event_occurred";
+                    eventName: string;
+                    withinMs?: number | undefined;
+                }>, z.ZodObject<{
+                    type: z.ZodLiteral<"state_equals">;
+                    key: z.ZodString;
+                    value: z.ZodUnknown;
+                }, "strip", z.ZodTypeAny, {
+                    type: "state_equals";
+                    key: string;
+                    value?: unknown;
+                }, {
+                    type: "state_equals";
+                    key: string;
+                    value?: unknown;
+                }>, z.ZodObject<{
+                    type: z.ZodLiteral<"viewport">;
+                    minWidth: z.ZodOptional<z.ZodNumber>;
+                    maxWidth: z.ZodOptional<z.ZodNumber>;
+                    minHeight: z.ZodOptional<z.ZodNumber>;
+                    maxHeight: z.ZodOptional<z.ZodNumber>;
+                }, "strip", z.ZodTypeAny, {
+                    type: "viewport";
+                    minWidth?: number | undefined;
+                    maxWidth?: number | undefined;
+                    minHeight?: number | undefined;
+                    maxHeight?: number | undefined;
+                }, {
+                    type: "viewport";
+                    minWidth?: number | undefined;
+                    maxWidth?: number | undefined;
+                    minHeight?: number | undefined;
+                    maxHeight?: number | undefined;
+                }>, z.ZodObject<{
+                    type: z.ZodLiteral<"session_metric">;
+                    key: z.ZodString;
+                    operator: z.ZodEnum<["gte", "lte", "eq", "gt", "lt"]>;
+                    threshold: z.ZodNumber;
+                }, "strip", z.ZodTypeAny, {
+                    type: "session_metric";
+                    key: string;
+                    operator: "gte" | "lte" | "eq" | "gt" | "lt";
+                    threshold: number;
+                }, {
+                    type: "session_metric";
+                    key: string;
+                    operator: "gte" | "lte" | "eq" | "gt" | "lt";
+                    threshold: number;
+                }>, z.ZodObject<{
+                    type: z.ZodLiteral<"dismissed">;
+                    key: z.ZodString;
+                    inverted: z.ZodOptional<z.ZodBoolean>;
+                }, "strip", z.ZodTypeAny, {
+                    type: "dismissed";
+                    key: string;
+                    inverted?: boolean | undefined;
+                }, {
+                    type: "dismissed";
+                    key: string;
+                    inverted?: boolean | undefined;
+                }>, z.ZodObject<{
+                    type: z.ZodLiteral<"cooldown_active">;
+                    key: z.ZodString;
+                    inverted: z.ZodOptional<z.ZodBoolean>;
+                }, "strip", z.ZodTypeAny, {
+                    type: "cooldown_active";
+                    key: string;
+                    inverted?: boolean | undefined;
+                }, {
+                    type: "cooldown_active";
+                    key: string;
+                    inverted?: boolean | undefined;
+                }>, z.ZodObject<{
+                    type: z.ZodLiteral<"frequency_limit">;
+                    key: z.ZodString;
+                    limit: z.ZodNumber;
+                    inverted: z.ZodOptional<z.ZodBoolean>;
+                }, "strip", z.ZodTypeAny, {
+                    type: "frequency_limit";
+                    key: string;
+                    limit: number;
+                    inverted?: boolean | undefined;
+                }, {
+                    type: "frequency_limit";
+                    key: string;
+                    limit: number;
+                    inverted?: boolean | undefined;
+                }>, z.ZodObject<{
+                    type: z.ZodLiteral<"event_count">;
+                    key: z.ZodString;
+                    operator: z.ZodEnum<["gte", "lte", "eq", "gt", "lt"]>;
+                    count: z.ZodNumber;
+                    withinMs: z.ZodOptional<z.ZodNumber>;
+                    counter: z.ZodOptional<z.ZodObject<{
+                        events: z.ZodArray<z.ZodString, "many">;
+                        match: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+                            equals: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+                            contains: z.ZodOptional<z.ZodString>;
+                        }, "strip", z.ZodTypeAny, {
+                            equals?: string | number | boolean | undefined;
+                            contains?: string | undefined;
+                        }, {
+                            equals?: string | number | boolean | undefined;
+                            contains?: string | undefined;
+                        }>>>;
+                    }, "strip", z.ZodTypeAny, {
+                        events: string[];
+                        match?: Record<string, {
+                            equals?: string | number | boolean | undefined;
+                            contains?: string | undefined;
+                        }> | undefined;
+                    }, {
+                        events: string[];
+                        match?: Record<string, {
+                            equals?: string | number | boolean | undefined;
+                            contains?: string | undefined;
+                        }> | undefined;
+                    }>>;
+                }, "strip", z.ZodTypeAny, {
+                    type: "event_count";
+                    key: string;
+                    operator: "gte" | "lte" | "eq" | "gt" | "lt";
+                    count: number;
+                    withinMs?: number | undefined;
+                    counter?: {
+                        events: string[];
+                        match?: Record<string, {
+                            equals?: string | number | boolean | undefined;
+                            contains?: string | undefined;
+                        }> | undefined;
+                    } | undefined;
+                }, {
+                    type: "event_count";
+                    key: string;
+                    operator: "gte" | "lte" | "eq" | "gt" | "lt";
+                    count: number;
+                    withinMs?: number | undefined;
+                    counter?: {
+                        events: string[];
+                        match?: Record<string, {
+                            equals?: string | number | boolean | undefined;
+                            contains?: string | undefined;
+                        }> | undefined;
+                    } | undefined;
+                }>]>, "many">;
                 value: z.ZodUnknown;
             }, "strip", z.ZodTypeAny, {
-                conditions: z.objectOutputType<{
-                    type: z.ZodString;
-                }, z.ZodTypeAny, "passthrough">[];
+                conditions: ({
+                    type: "page_url";
+                    url: string;
+                } | {
+                    type: "route";
+                    routeId: string;
+                } | {
+                    type: "anchor_visible";
+                    anchorId: string;
+                    state: "visible" | "present" | "absent";
+                } | {
+                    type: "event_occurred";
+                    eventName: string;
+                    withinMs?: number | undefined;
+                } | {
+                    type: "state_equals";
+                    key: string;
+                    value?: unknown;
+                } | {
+                    type: "viewport";
+                    minWidth?: number | undefined;
+                    maxWidth?: number | undefined;
+                    minHeight?: number | undefined;
+                    maxHeight?: number | undefined;
+                } | {
+                    type: "session_metric";
+                    key: string;
+                    operator: "gte" | "lte" | "eq" | "gt" | "lt";
+                    threshold: number;
+                } | {
+                    type: "dismissed";
+                    key: string;
+                    inverted?: boolean | undefined;
+                } | {
+                    type: "cooldown_active";
+                    key: string;
+                    inverted?: boolean | undefined;
+                } | {
+                    type: "frequency_limit";
+                    key: string;
+                    limit: number;
+                    inverted?: boolean | undefined;
+                } | {
+                    type: "event_count";
+                    key: string;
+                    operator: "gte" | "lte" | "eq" | "gt" | "lt";
+                    count: number;
+                    withinMs?: number | undefined;
+                    counter?: {
+                        events: string[];
+                        match?: Record<string, {
+                            equals?: string | number | boolean | undefined;
+                            contains?: string | undefined;
+                        }> | undefined;
+                    } | undefined;
+                })[];
                 value?: unknown;
             }, {
-                conditions: z.objectInputType<{
-                    type: z.ZodString;
-                }, z.ZodTypeAny, "passthrough">[];
+                conditions: ({
+                    type: "page_url";
+                    url: string;
+                } | {
+                    type: "route";
+                    routeId: string;
+                } | {
+                    type: "anchor_visible";
+                    anchorId: string;
+                    state: "visible" | "present" | "absent";
+                } | {
+                    type: "event_occurred";
+                    eventName: string;
+                    withinMs?: number | undefined;
+                } | {
+                    type: "state_equals";
+                    key: string;
+                    value?: unknown;
+                } | {
+                    type: "viewport";
+                    minWidth?: number | undefined;
+                    maxWidth?: number | undefined;
+                    minHeight?: number | undefined;
+                    maxHeight?: number | undefined;
+                } | {
+                    type: "session_metric";
+                    key: string;
+                    operator: "gte" | "lte" | "eq" | "gt" | "lt";
+                    threshold: number;
+                } | {
+                    type: "dismissed";
+                    key: string;
+                    inverted?: boolean | undefined;
+                } | {
+                    type: "cooldown_active";
+                    key: string;
+                    inverted?: boolean | undefined;
+                } | {
+                    type: "frequency_limit";
+                    key: string;
+                    limit: number;
+                    inverted?: boolean | undefined;
+                } | {
+                    type: "event_count";
+                    key: string;
+                    operator: "gte" | "lte" | "eq" | "gt" | "lt";
+                    count: number;
+                    withinMs?: number | undefined;
+                    counter?: {
+                        events: string[];
+                        match?: Record<string, {
+                            equals?: string | number | boolean | undefined;
+                            contains?: string | undefined;
+                        }> | undefined;
+                    } | undefined;
+                })[];
                 value?: unknown;
             }>, "many">;
             default: z.ZodUnknown;
         }, "strip", z.ZodTypeAny, {
             type: "rules";
             rules: {
-                conditions: z.objectOutputType<{
-                    type: z.ZodString;
-                }, z.ZodTypeAny, "passthrough">[];
+                conditions: ({
+                    type: "page_url";
+                    url: string;
+                } | {
+                    type: "route";
+                    routeId: string;
+                } | {
+                    type: "anchor_visible";
+                    anchorId: string;
+                    state: "visible" | "present" | "absent";
+                } | {
+                    type: "event_occurred";
+                    eventName: string;
+                    withinMs?: number | undefined;
+                } | {
+                    type: "state_equals";
+                    key: string;
+                    value?: unknown;
+                } | {
+                    type: "viewport";
+                    minWidth?: number | undefined;
+                    maxWidth?: number | undefined;
+                    minHeight?: number | undefined;
+                    maxHeight?: number | undefined;
+                } | {
+                    type: "session_metric";
+                    key: string;
+                    operator: "gte" | "lte" | "eq" | "gt" | "lt";
+                    threshold: number;
+                } | {
+                    type: "dismissed";
+                    key: string;
+                    inverted?: boolean | undefined;
+                } | {
+                    type: "cooldown_active";
+                    key: string;
+                    inverted?: boolean | undefined;
+                } | {
+                    type: "frequency_limit";
+                    key: string;
+                    limit: number;
+                    inverted?: boolean | undefined;
+                } | {
+                    type: "event_count";
+                    key: string;
+                    operator: "gte" | "lte" | "eq" | "gt" | "lt";
+                    count: number;
+                    withinMs?: number | undefined;
+                    counter?: {
+                        events: string[];
+                        match?: Record<string, {
+                            equals?: string | number | boolean | undefined;
+                            contains?: string | undefined;
+                        }> | undefined;
+                    } | undefined;
+                })[];
                 value?: unknown;
             }[];
             default?: unknown;
         }, {
             type: "rules";
             rules: {
-                conditions: z.objectInputType<{
-                    type: z.ZodString;
-                }, z.ZodTypeAny, "passthrough">[];
+                conditions: ({
+                    type: "page_url";
+                    url: string;
+                } | {
+                    type: "route";
+                    routeId: string;
+                } | {
+                    type: "anchor_visible";
+                    anchorId: string;
+                    state: "visible" | "present" | "absent";
+                } | {
+                    type: "event_occurred";
+                    eventName: string;
+                    withinMs?: number | undefined;
+                } | {
+                    type: "state_equals";
+                    key: string;
+                    value?: unknown;
+                } | {
+                    type: "viewport";
+                    minWidth?: number | undefined;
+                    maxWidth?: number | undefined;
+                    minHeight?: number | undefined;
+                    maxHeight?: number | undefined;
+                } | {
+                    type: "session_metric";
+                    key: string;
+                    operator: "gte" | "lte" | "eq" | "gt" | "lt";
+                    threshold: number;
+                } | {
+                    type: "dismissed";
+                    key: string;
+                    inverted?: boolean | undefined;
+                } | {
+                    type: "cooldown_active";
+                    key: string;
+                    inverted?: boolean | undefined;
+                } | {
+                    type: "frequency_limit";
+                    key: string;
+                    limit: number;
+                    inverted?: boolean | undefined;
+                } | {
+                    type: "event_count";
+                    key: string;
+                    operator: "gte" | "lte" | "eq" | "gt" | "lt";
+                    count: number;
+                    withinMs?: number | undefined;
+                    counter?: {
+                        events: string[];
+                        match?: Record<string, {
+                            equals?: string | number | boolean | undefined;
+                            contains?: string | undefined;
+                        }> | undefined;
+                    } | undefined;
+                })[];
                 value?: unknown;
             }[];
             default?: unknown;
@@ -208,14 +1924,14 @@ export declare const AwardBadgeSchema: z.ZodObject<{
             below: z.ZodUnknown;
         }, "strip", z.ZodTypeAny, {
             type: "score";
-            field: string;
             threshold: number;
+            field: string;
             above?: unknown;
             below?: unknown;
         }, {
             type: "score";
-            field: string;
             threshold: number;
+            field: string;
             above?: unknown;
             below?: unknown;
         }>, z.ZodObject<{
@@ -254,97 +1970,78 @@ export declare const AwardBadgeSchema: z.ZodObject<{
             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?: {
+        badgeId: string;
+        kind: "gamification:awardBadge";
+        anchorId?: string | undefined;
+        label?: string | undefined;
+        triggerWhen?: {
             type: "rules";
             rules: {
-                conditions: z.objectInputType<{
-                    type: z.ZodString;
-                }, z.ZodTypeAny, "passthrough">[];
+                conditions: ({
+                    type: "page_url";
+                    url: string;
+                } | {
+                    type: "route";
+                    routeId: string;
+                } | {
+                    type: "anchor_visible";
+                    anchorId: string;
+                    state: "visible" | "present" | "absent";
+                } | {
+                    type: "event_occurred";
+                    eventName: string;
+                    withinMs?: number | undefined;
+                } | {
+                    type: "state_equals";
+                    key: string;
+                    value?: unknown;
+                } | {
+                    type: "viewport";
+                    minWidth?: number | undefined;
+                    maxWidth?: number | undefined;
+                    minHeight?: number | undefined;
+                    maxHeight?: number | undefined;
+                } | {
+                    type: "session_metric";
+                    key: string;
+                    operator: "gte" | "lte" | "eq" | "gt" | "lt";
+                    threshold: number;
+                } | {
+                    type: "dismissed";
+                    key: string;
+                    inverted?: boolean | undefined;
+                } | {
+                    type: "cooldown_active";
+                    key: string;
+                    inverted?: boolean | undefined;
+                } | {
+                    type: "frequency_limit";
+                    key: string;
+                    limit: number;
+                    inverted?: boolean | undefined;
+                } | {
+                    type: "event_count";
+                    key: string;
+                    operator: "gte" | "lte" | "eq" | "gt" | "lt";
+                    count: number;
+                    withinMs?: number | undefined;
+                    counter?: {
+                        events: string[];
+                        match?: Record<string, {
+                            equals?: string | number | boolean | undefined;
+                            contains?: string | undefined;
+                        }> | undefined;
+                    } | undefined;
+                })[];
                 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;
         } | {
@@ -359,31 +2056,78 @@ export declare const AwardBadgeSchema: z.ZodObject<{
             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?: {
+        } | null | undefined;
+    }, {
+        badgeId: string;
+        kind: "gamification:awardBadge";
+        anchorId?: string | undefined;
+        label?: string | undefined;
+        triggerWhen?: {
             type: "rules";
             rules: {
-                conditions: z.objectInputType<{
-                    type: z.ZodString;
-                }, z.ZodTypeAny, "passthrough">[];
+                conditions: ({
+                    type: "page_url";
+                    url: string;
+                } | {
+                    type: "route";
+                    routeId: string;
+                } | {
+                    type: "anchor_visible";
+                    anchorId: string;
+                    state: "visible" | "present" | "absent";
+                } | {
+                    type: "event_occurred";
+                    eventName: string;
+                    withinMs?: number | undefined;
+                } | {
+                    type: "state_equals";
+                    key: string;
+                    value?: unknown;
+                } | {
+                    type: "viewport";
+                    minWidth?: number | undefined;
+                    maxWidth?: number | undefined;
+                    minHeight?: number | undefined;
+                    maxHeight?: number | undefined;
+                } | {
+                    type: "session_metric";
+                    key: string;
+                    operator: "gte" | "lte" | "eq" | "gt" | "lt";
+                    threshold: number;
+                } | {
+                    type: "dismissed";
+                    key: string;
+                    inverted?: boolean | undefined;
+                } | {
+                    type: "cooldown_active";
+                    key: string;
+                    inverted?: boolean | undefined;
+                } | {
+                    type: "frequency_limit";
+                    key: string;
+                    limit: number;
+                    inverted?: boolean | undefined;
+                } | {
+                    type: "event_count";
+                    key: string;
+                    operator: "gte" | "lte" | "eq" | "gt" | "lt";
+                    count: number;
+                    withinMs?: number | undefined;
+                    counter?: {
+                        events: string[];
+                        match?: Record<string, {
+                            equals?: string | number | boolean | undefined;
+                            contains?: string | undefined;
+                        }> | undefined;
+                    } | undefined;
+                })[];
                 value?: unknown;
             }[];
             default?: unknown;
         } | {
             type: "score";
-            field: string;
             threshold: number;
+            field: string;
             above?: unknown;
             below?: unknown;
         } | {
@@ -398,67 +2142,443 @@ export declare const AwardBadgeSchema: z.ZodObject<{
             default?: unknown;
             method?: "GET" | "POST" | undefined;
             timeoutMs?: number | undefined;
-        } | undefined;
-    } | undefined;
-}>;
-/**
- * Schema for adding points to a user's score.
- */
-export declare const AddPointsSchema: z.ZodObject<{
-    kind: z.ZodLiteral<"gamification:addPoints">;
-    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<{
+        } | null | undefined;
+    }>;
+} | {
+    defName: string;
+    schema: z.ZodObject<{
+        kind: z.ZodLiteral<"gamification:addPoints">;
+        points: z.ZodNumber;
+        reason: z.ZodOptional<z.ZodString>;
+        label: z.ZodOptional<z.ZodString>;
+    } & {
+        triggerWhen: z.ZodOptional<z.ZodNullable<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">;
+                conditions: z.ZodArray<z.ZodDiscriminatedUnion<"type", [z.ZodObject<{
+                    type: z.ZodLiteral<"page_url">;
+                    url: z.ZodString;
+                }, "strip", z.ZodTypeAny, {
+                    type: "page_url";
+                    url: string;
+                }, {
+                    type: "page_url";
+                    url: string;
+                }>, z.ZodObject<{
+                    type: z.ZodLiteral<"route">;
+                    routeId: z.ZodString;
+                }, "strip", z.ZodTypeAny, {
+                    type: "route";
+                    routeId: string;
+                }, {
+                    type: "route";
+                    routeId: string;
+                }>, z.ZodObject<{
+                    type: z.ZodLiteral<"anchor_visible">;
+                    anchorId: z.ZodString;
+                    state: z.ZodEnum<["visible", "present", "absent"]>;
+                }, "strip", z.ZodTypeAny, {
+                    type: "anchor_visible";
+                    anchorId: string;
+                    state: "visible" | "present" | "absent";
+                }, {
+                    type: "anchor_visible";
+                    anchorId: string;
+                    state: "visible" | "present" | "absent";
+                }>, z.ZodObject<{
+                    type: z.ZodLiteral<"event_occurred">;
+                    eventName: z.ZodString;
+                    withinMs: z.ZodOptional<z.ZodNumber>;
+                }, "strip", z.ZodTypeAny, {
+                    type: "event_occurred";
+                    eventName: string;
+                    withinMs?: number | undefined;
+                }, {
+                    type: "event_occurred";
+                    eventName: string;
+                    withinMs?: number | undefined;
+                }>, z.ZodObject<{
+                    type: z.ZodLiteral<"state_equals">;
+                    key: z.ZodString;
+                    value: z.ZodUnknown;
+                }, "strip", z.ZodTypeAny, {
+                    type: "state_equals";
+                    key: string;
+                    value?: unknown;
+                }, {
+                    type: "state_equals";
+                    key: string;
+                    value?: unknown;
+                }>, z.ZodObject<{
+                    type: z.ZodLiteral<"viewport">;
+                    minWidth: z.ZodOptional<z.ZodNumber>;
+                    maxWidth: z.ZodOptional<z.ZodNumber>;
+                    minHeight: z.ZodOptional<z.ZodNumber>;
+                    maxHeight: z.ZodOptional<z.ZodNumber>;
+                }, "strip", z.ZodTypeAny, {
+                    type: "viewport";
+                    minWidth?: number | undefined;
+                    maxWidth?: number | undefined;
+                    minHeight?: number | undefined;
+                    maxHeight?: number | undefined;
+                }, {
+                    type: "viewport";
+                    minWidth?: number | undefined;
+                    maxWidth?: number | undefined;
+                    minHeight?: number | undefined;
+                    maxHeight?: number | undefined;
+                }>, z.ZodObject<{
+                    type: z.ZodLiteral<"session_metric">;
+                    key: z.ZodString;
+                    operator: z.ZodEnum<["gte", "lte", "eq", "gt", "lt"]>;
+                    threshold: z.ZodNumber;
+                }, "strip", z.ZodTypeAny, {
+                    type: "session_metric";
+                    key: string;
+                    operator: "gte" | "lte" | "eq" | "gt" | "lt";
+                    threshold: number;
+                }, {
+                    type: "session_metric";
+                    key: string;
+                    operator: "gte" | "lte" | "eq" | "gt" | "lt";
+                    threshold: number;
+                }>, z.ZodObject<{
+                    type: z.ZodLiteral<"dismissed">;
+                    key: z.ZodString;
+                    inverted: z.ZodOptional<z.ZodBoolean>;
+                }, "strip", z.ZodTypeAny, {
+                    type: "dismissed";
+                    key: string;
+                    inverted?: boolean | undefined;
+                }, {
+                    type: "dismissed";
+                    key: string;
+                    inverted?: boolean | undefined;
+                }>, z.ZodObject<{
+                    type: z.ZodLiteral<"cooldown_active">;
+                    key: z.ZodString;
+                    inverted: z.ZodOptional<z.ZodBoolean>;
+                }, "strip", z.ZodTypeAny, {
+                    type: "cooldown_active";
+                    key: string;
+                    inverted?: boolean | undefined;
+                }, {
+                    type: "cooldown_active";
+                    key: string;
+                    inverted?: boolean | undefined;
+                }>, z.ZodObject<{
+                    type: z.ZodLiteral<"frequency_limit">;
+                    key: z.ZodString;
+                    limit: z.ZodNumber;
+                    inverted: z.ZodOptional<z.ZodBoolean>;
+                }, "strip", z.ZodTypeAny, {
+                    type: "frequency_limit";
+                    key: string;
+                    limit: number;
+                    inverted?: boolean | undefined;
+                }, {
+                    type: "frequency_limit";
+                    key: string;
+                    limit: number;
+                    inverted?: boolean | undefined;
+                }>, z.ZodObject<{
+                    type: z.ZodLiteral<"event_count">;
+                    key: z.ZodString;
+                    operator: z.ZodEnum<["gte", "lte", "eq", "gt", "lt"]>;
+                    count: z.ZodNumber;
+                    withinMs: z.ZodOptional<z.ZodNumber>;
+                    counter: z.ZodOptional<z.ZodObject<{
+                        events: z.ZodArray<z.ZodString, "many">;
+                        match: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+                            equals: z.ZodOptional<z.ZodUnion<[z.ZodString, z.ZodNumber, z.ZodBoolean]>>;
+                            contains: z.ZodOptional<z.ZodString>;
+                        }, "strip", z.ZodTypeAny, {
+                            equals?: string | number | boolean | undefined;
+                            contains?: string | undefined;
+                        }, {
+                            equals?: string | number | boolean | undefined;
+                            contains?: string | undefined;
+                        }>>>;
+                    }, "strip", z.ZodTypeAny, {
+                        events: string[];
+                        match?: Record<string, {
+                            equals?: string | number | boolean | undefined;
+                            contains?: string | undefined;
+                        }> | undefined;
+                    }, {
+                        events: string[];
+                        match?: Record<string, {
+                            equals?: string | number | boolean | undefined;
+                            contains?: string | undefined;
+                        }> | undefined;
+                    }>>;
+                }, "strip", z.ZodTypeAny, {
+                    type: "event_count";
+                    key: string;
+                    operator: "gte" | "lte" | "eq" | "gt" | "lt";
+                    count: number;
+                    withinMs?: number | undefined;
+                    counter?: {
+                        events: string[];
+                        match?: Record<string, {
+                            equals?: string | number | boolean | undefined;
+                            contains?: string | undefined;
+                        }> | undefined;
+                    } | undefined;
+                }, {
+                    type: "event_count";
+                    key: string;
+                    operator: "gte" | "lte" | "eq" | "gt" | "lt";
+                    count: number;
+                    withinMs?: number | undefined;
+                    counter?: {
+                        events: string[];
+                        match?: Record<string, {
+                            equals?: string | number | boolean | undefined;
+                            contains?: string | undefined;
+                        }> | undefined;
+                    } | undefined;
+                }>]>, "many">;
                 value: z.ZodUnknown;
             }, "strip", z.ZodTypeAny, {
-                conditions: z.objectOutputType<{
-                    type: z.ZodString;
-                }, z.ZodTypeAny, "passthrough">[];
+                conditions: ({
+                    type: "page_url";
+                    url: string;
+                } | {
+                    type: "route";
+                    routeId: string;
+                } | {
+                    type: "anchor_visible";
+                    anchorId: string;
+                    state: "visible" | "present" | "absent";
+                } | {
+                    type: "event_occurred";
+                    eventName: string;
+                    withinMs?: number | undefined;
+                } | {
+                    type: "state_equals";
+                    key: string;
+                    value?: unknown;
+                } | {
+                    type: "viewport";
+                    minWidth?: number | undefined;
+                    maxWidth?: number | undefined;
+                    minHeight?: number | undefined;
+                    maxHeight?: number | undefined;
+                } | {
+                    type: "session_metric";
+                    key: string;
+                    operator: "gte" | "lte" | "eq" | "gt" | "lt";
+                    threshold: number;
+                } | {
+                    type: "dismissed";
+                    key: string;
+                    inverted?: boolean | undefined;
+                } | {
+                    type: "cooldown_active";
+                    key: string;
+                    inverted?: boolean | undefined;
+                } | {
+                    type: "frequency_limit";
+                    key: string;
+                    limit: number;
+                    inverted?: boolean | undefined;
+                } | {
+                    type: "event_count";
+                    key: string;
+                    operator: "gte" | "lte" | "eq" | "gt" | "lt";
+                    count: number;
+                    withinMs?: number | undefined;
+                    counter?: {
+                        events: string[];
+                        match?: Record<string, {
+                            equals?: string | number | boolean | undefined;
+                            contains?: string | undefined;
+                        }> | undefined;
+                    } | undefined;
+                })[];
                 value?: unknown;
             }, {
-                conditions: z.objectInputType<{
-                    type: z.ZodString;
-                }, z.ZodTypeAny, "passthrough">[];
+                conditions: ({
+                    type: "page_url";
+                    url: string;
+                } | {
+                    type: "route";
+                    routeId: string;
+                } | {
+                    type: "anchor_visible";
+                    anchorId: string;
+                    state: "visible" | "present" | "absent";
+                } | {
+                    type: "event_occurred";
+                    eventName: string;
+                    withinMs?: number | undefined;
+                } | {
+                    type: "state_equals";
+                    key: string;
+                    value?: unknown;
+                } | {
+                    type: "viewport";
+                    minWidth?: number | undefined;
+                    maxWidth?: number | undefined;
+                    minHeight?: number | undefined;
+                    maxHeight?: number | undefined;
+                } | {
+                    type: "session_metric";
+                    key: string;
+                    operator: "gte" | "lte" | "eq" | "gt" | "lt";
+                    threshold: number;
+                } | {
+                    type: "dismissed";
+                    key: string;
+                    inverted?: boolean | undefined;
+                } | {
+                    type: "cooldown_active";
+                    key: string;
+                    inverted?: boolean | undefined;
+                } | {
+                    type: "frequency_limit";
+                    key: string;
+                    limit: number;
+                    inverted?: boolean | undefined;
+                } | {
+                    type: "event_count";
+                    key: string;
+                    operator: "gte" | "lte" | "eq" | "gt" | "lt";
+                    count: number;
+                    withinMs?: number | undefined;
+                    counter?: {
+                        events: string[];
+                        match?: Record<string, {
+                            equals?: string | number | boolean | undefined;
+                            contains?: string | undefined;
+                        }> | undefined;
+                    } | undefined;
+                })[];
                 value?: unknown;
             }>, "many">;
             default: z.ZodUnknown;
         }, "strip", z.ZodTypeAny, {
             type: "rules";
             rules: {
-                conditions: z.objectOutputType<{
-                    type: z.ZodString;
-                }, z.ZodTypeAny, "passthrough">[];
+                conditions: ({
+                    type: "page_url";
+                    url: string;
+                } | {
+                    type: "route";
+                    routeId: string;
+                } | {
+                    type: "anchor_visible";
+                    anchorId: string;
+                    state: "visible" | "present" | "absent";
+                } | {
+                    type: "event_occurred";
+                    eventName: string;
+                    withinMs?: number | undefined;
+                } | {
+                    type: "state_equals";
+                    key: string;
+                    value?: unknown;
+                } | {
+                    type: "viewport";
+                    minWidth?: number | undefined;
+                    maxWidth?: number | undefined;
+                    minHeight?: number | undefined;
+                    maxHeight?: number | undefined;
+                } | {
+                    type: "session_metric";
+                    key: string;
+                    operator: "gte" | "lte" | "eq" | "gt" | "lt";
+                    threshold: number;
+                } | {
+                    type: "dismissed";
+                    key: string;
+                    inverted?: boolean | undefined;
+                } | {
+                    type: "cooldown_active";
+                    key: string;
+                    inverted?: boolean | undefined;
+                } | {
+                    type: "frequency_limit";
+                    key: string;
+                    limit: number;
+                    inverted?: boolean | undefined;
+                } | {
+                    type: "event_count";
+                    key: string;
+                    operator: "gte" | "lte" | "eq" | "gt" | "lt";
+                    count: number;
+                    withinMs?: number | undefined;
+                    counter?: {
+                        events: string[];
+                        match?: Record<string, {
+                            equals?: string | number | boolean | undefined;
+                            contains?: string | undefined;
+                        }> | undefined;
+                    } | undefined;
+                })[];
                 value?: unknown;
             }[];
             default?: unknown;
         }, {
             type: "rules";
             rules: {
-                conditions: z.objectInputType<{
-                    type: z.ZodString;
-                }, z.ZodTypeAny, "passthrough">[];
+                conditions: ({
+                    type: "page_url";
+                    url: string;
+                } | {
+                    type: "route";
+                    routeId: string;
+                } | {
+                    type: "anchor_visible";
+                    anchorId: string;
+                    state: "visible" | "present" | "absent";
+                } | {
+                    type: "event_occurred";
+                    eventName: string;
+                    withinMs?: number | undefined;
+                } | {
+                    type: "state_equals";
+                    key: string;
+                    value?: unknown;
+                } | {
+                    type: "viewport";
+                    minWidth?: number | undefined;
+                    maxWidth?: number | undefined;
+                    minHeight?: number | undefined;
+                    maxHeight?: number | undefined;
+                } | {
+                    type: "session_metric";
+                    key: string;
+                    operator: "gte" | "lte" | "eq" | "gt" | "lt";
+                    threshold: number;
+                } | {
+                    type: "dismissed";
+                    key: string;
+                    inverted?: boolean | undefined;
+                } | {
+                    type: "cooldown_active";
+                    key: string;
+                    inverted?: boolean | undefined;
+                } | {
+                    type: "frequency_limit";
+                    key: string;
+                    limit: number;
+                    inverted?: boolean | undefined;
+                } | {
+                    type: "event_count";
+                    key: string;
+                    operator: "gte" | "lte" | "eq" | "gt" | "lt";
+                    count: number;
+                    withinMs?: number | undefined;
+                    counter?: {
+                        events: string[];
+                        match?: Record<string, {
+                            equals?: string | number | boolean | undefined;
+                            contains?: string | undefined;
+                        }> | undefined;
+                    } | undefined;
+                })[];
                 value?: unknown;
             }[];
             default?: unknown;
@@ -470,14 +2590,14 @@ export declare const AddPointsSchema: z.ZodObject<{
             below: z.ZodUnknown;
         }, "strip", z.ZodTypeAny, {
             type: "score";
-            field: string;
             threshold: number;
+            field: string;
             above?: unknown;
             below?: unknown;
         }, {
             type: "score";
-            field: string;
             threshold: number;
+            field: string;
             above?: unknown;
             below?: unknown;
         }>, z.ZodObject<{
@@ -516,58 +2636,78 @@ export declare const AddPointsSchema: z.ZodObject<{
             default?: unknown;
             method?: "GET" | "POST" | undefined;
             timeoutMs?: number | undefined;
-        }>]>>;
+        }>]>>>;
     }, "strip", z.ZodTypeAny, {
-        routes: {
-            include?: string[] | undefined;
-            exclude?: string[] | undefined;
-        };
-        strategy?: {
+        points: number;
+        kind: "gamification:addPoints";
+        reason?: string | undefined;
+        label?: string | undefined;
+        triggerWhen?: {
             type: "rules";
             rules: {
-                conditions: z.objectOutputType<{
-                    type: z.ZodString;
-                }, z.ZodTypeAny, "passthrough">[];
+                conditions: ({
+                    type: "page_url";
+                    url: string;
+                } | {
+                    type: "route";
+                    routeId: string;
+                } | {
+                    type: "anchor_visible";
+                    anchorId: string;
+                    state: "visible" | "present" | "absent";
+                } | {
+                    type: "event_occurred";
+                    eventName: string;
+                    withinMs?: number | undefined;
+                } | {
+                    type: "state_equals";
+                    key: string;
+                    value?: unknown;
+                } | {
+                    type: "viewport";
+                    minWidth?: number | undefined;
+                    maxWidth?: number | undefined;
+                    minHeight?: number | undefined;
+                    maxHeight?: number | undefined;
+                } | {
+                    type: "session_metric";
+                    key: string;
+                    operator: "gte" | "lte" | "eq" | "gt" | "lt";
+                    threshold: number;
+                } | {
+                    type: "dismissed";
+                    key: string;
+                    inverted?: boolean | undefined;
+                } | {
+                    type: "cooldown_active";
+                    key: string;
+                    inverted?: boolean | undefined;
+                } | {
+                    type: "frequency_limit";
+                    key: string;
+                    limit: number;
+                    inverted?: boolean | undefined;
+                } | {
+                    type: "event_count";
+                    key: string;
+                    operator: "gte" | "lte" | "eq" | "gt" | "lt";
+                    count: number;
+                    withinMs?: number | undefined;
+                    counter?: {
+                        events: string[];
+                        match?: Record<string, {
+                            equals?: string | number | boolean | undefined;
+                            contains?: string | undefined;
+                        }> | undefined;
+                    } | undefined;
+                })[];
                 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;
         } | {
@@ -582,70 +2722,78 @@ export declare const AddPointsSchema: z.ZodObject<{
             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?: {
+        } | null | undefined;
+    }, {
+        points: number;
+        kind: "gamification:addPoints";
+        reason?: string | undefined;
+        label?: string | undefined;
+        triggerWhen?: {
             type: "rules";
             rules: {
-                conditions: z.objectOutputType<{
-                    type: z.ZodString;
-                }, z.ZodTypeAny, "passthrough">[];
+                conditions: ({
+                    type: "page_url";
+                    url: string;
+                } | {
+                    type: "route";
+                    routeId: string;
+                } | {
+                    type: "anchor_visible";
+                    anchorId: string;
+                    state: "visible" | "present" | "absent";
+                } | {
+                    type: "event_occurred";
+                    eventName: string;
+                    withinMs?: number | undefined;
+                } | {
+                    type: "state_equals";
+                    key: string;
+                    value?: unknown;
+                } | {
+                    type: "viewport";
+                    minWidth?: number | undefined;
+                    maxWidth?: number | undefined;
+                    minHeight?: number | undefined;
+                    maxHeight?: number | undefined;
+                } | {
+                    type: "session_metric";
+                    key: string;
+                    operator: "gte" | "lte" | "eq" | "gt" | "lt";
+                    threshold: number;
+                } | {
+                    type: "dismissed";
+                    key: string;
+                    inverted?: boolean | undefined;
+                } | {
+                    type: "cooldown_active";
+                    key: string;
+                    inverted?: boolean | undefined;
+                } | {
+                    type: "frequency_limit";
+                    key: string;
+                    limit: number;
+                    inverted?: boolean | undefined;
+                } | {
+                    type: "event_count";
+                    key: string;
+                    operator: "gte" | "lte" | "eq" | "gt" | "lt";
+                    count: number;
+                    withinMs?: number | undefined;
+                    counter?: {
+                        events: string[];
+                        match?: Record<string, {
+                            equals?: string | number | boolean | undefined;
+                            contains?: string | undefined;
+                        }> | undefined;
+                    } | undefined;
+                })[];
                 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;
         } | {
@@ -660,535 +2808,7 @@ export declare const AddPointsSchema: z.ZodObject<{
             default?: unknown;
             method?: "GET" | "POST" | undefined;
             timeoutMs?: number | undefined;
-        } | undefined;
-    } | undefined;
-}>;
-/**
- * Action step schemas for unified JSON Schema generation.
- * The build script reads this array to merge adaptive actions into the
- * unified canvas-config.schema.json.
- */
-export declare const actionStepSchemas: ({
-    defName: string;
-    schema: z.ZodObject<{
-        kind: z.ZodLiteral<"gamification:awardBadge">;
-        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;
-    schema: z.ZodObject<{
-        kind: z.ZodLiteral<"gamification:addPoints">;
-        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;
+        } | null | undefined;
     }>;
 })[];
 //# sourceMappingURL=schema.d.ts.map