@cat-factory/contracts 0.166.0 → 0.168.0

package/dist/routes/merge.d.ts

@@ -47,6 +47,65 @@ export declare const listRiskPoliciesContract: {
                 readonly minImpact: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 1, undefined>]>, undefined>;
                 readonly onMissingEstimate: v.OptionalSchema<v.PicklistSchema<["run", "skip"], undefined>, "run">;
             }, undefined>, undefined>, undefined>;
+            readonly classRules: Omit<v.StrictObjectSchema<{
+                config: v.PicklistSchema<["thresholds", "always", "never"], undefined>;
+                dependency: v.PicklistSchema<["thresholds", "always", "never"], undefined>;
+                docs: v.PicklistSchema<["thresholds", "always", "never"], undefined>;
+                schema: v.PicklistSchema<["thresholds", "always", "never"], undefined>;
+                source: v.PicklistSchema<["thresholds", "always", "never"], undefined>;
+                test: v.PicklistSchema<["thresholds", "always", "never"], undefined>;
+            }, undefined>, "entries" | "~run" | "~standard" | "~types"> & {
+                readonly entries: {
+                    config: v.OptionalSchema<v.PicklistSchema<["thresholds", "always", "never"], undefined>, undefined>;
+                    dependency: v.OptionalSchema<v.PicklistSchema<["thresholds", "always", "never"], undefined>, undefined>;
+                    docs: v.OptionalSchema<v.PicklistSchema<["thresholds", "always", "never"], undefined>, undefined>;
+                    schema: v.OptionalSchema<v.PicklistSchema<["thresholds", "always", "never"], undefined>, undefined>;
+                    source: v.OptionalSchema<v.PicklistSchema<["thresholds", "always", "never"], undefined>, undefined>;
+                    test: v.OptionalSchema<v.PicklistSchema<["thresholds", "always", "never"], undefined>, undefined>;
+                };
+                readonly "~standard": v.StandardProps<{
+                    config?: "always" | "never" | "thresholds" | undefined;
+                    dependency?: "always" | "never" | "thresholds" | undefined;
+                    docs?: "always" | "never" | "thresholds" | undefined;
+                    schema?: "always" | "never" | "thresholds" | undefined;
+                    source?: "always" | "never" | "thresholds" | undefined;
+                    test?: "always" | "never" | "thresholds" | undefined;
+                }, {
+                    config?: "always" | "never" | "thresholds" | undefined;
+                    dependency?: "always" | "never" | "thresholds" | undefined;
+                    docs?: "always" | "never" | "thresholds" | undefined;
+                    schema?: "always" | "never" | "thresholds" | undefined;
+                    source?: "always" | "never" | "thresholds" | undefined;
+                    test?: "always" | "never" | "thresholds" | undefined;
+                }>;
+                readonly "~run": (dataset: v.UnknownDataset, config: v.Config<v.BaseIssue<unknown>>) => v.OutputDataset<{
+                    config?: "always" | "never" | "thresholds" | undefined;
+                    dependency?: "always" | "never" | "thresholds" | undefined;
+                    docs?: "always" | "never" | "thresholds" | undefined;
+                    schema?: "always" | "never" | "thresholds" | undefined;
+                    source?: "always" | "never" | "thresholds" | undefined;
+                    test?: "always" | "never" | "thresholds" | undefined;
+                }, v.PicklistIssue | v.StrictObjectIssue>;
+                readonly "~types"?: {
+                    readonly input: {
+                        config?: "always" | "never" | "thresholds" | undefined;
+                        dependency?: "always" | "never" | "thresholds" | undefined;
+                        docs?: "always" | "never" | "thresholds" | undefined;
+                        schema?: "always" | "never" | "thresholds" | undefined;
+                        source?: "always" | "never" | "thresholds" | undefined;
+                        test?: "always" | "never" | "thresholds" | undefined;
+                    };
+                    readonly output: {
+                        config?: "always" | "never" | "thresholds" | undefined;
+                        dependency?: "always" | "never" | "thresholds" | undefined;
+                        docs?: "always" | "never" | "thresholds" | undefined;
+                        schema?: "always" | "never" | "thresholds" | undefined;
+                        source?: "always" | "never" | "thresholds" | undefined;
+                        test?: "always" | "never" | "thresholds" | undefined;
+                    };
+                    readonly issue: v.PicklistIssue | v.StrictObjectIssue;
+                } | undefined;
+            };
             readonly isDefault: v.BooleanSchema<undefined>;
             readonly version: v.OptionalSchema<v.NumberSchema<undefined>, undefined>;
             readonly createdAt: v.NumberSchema<undefined>;
@@ -76,6 +135,65 @@ export declare const createRiskPolicyContract: {
             readonly minImpact: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 1, undefined>]>, undefined>;
             readonly onMissingEstimate: v.OptionalSchema<v.PicklistSchema<["run", "skip"], undefined>, "run">;
         }, undefined>, undefined>, undefined>;
+        readonly classRules: v.OptionalSchema<Omit<v.StrictObjectSchema<{
+            config: v.PicklistSchema<["thresholds", "always", "never"], undefined>;
+            dependency: v.PicklistSchema<["thresholds", "always", "never"], undefined>;
+            docs: v.PicklistSchema<["thresholds", "always", "never"], undefined>;
+            schema: v.PicklistSchema<["thresholds", "always", "never"], undefined>;
+            source: v.PicklistSchema<["thresholds", "always", "never"], undefined>;
+            test: v.PicklistSchema<["thresholds", "always", "never"], undefined>;
+        }, undefined>, "entries" | "~run" | "~standard" | "~types"> & {
+            readonly entries: {
+                config: v.OptionalSchema<v.PicklistSchema<["thresholds", "always", "never"], undefined>, undefined>;
+                dependency: v.OptionalSchema<v.PicklistSchema<["thresholds", "always", "never"], undefined>, undefined>;
+                docs: v.OptionalSchema<v.PicklistSchema<["thresholds", "always", "never"], undefined>, undefined>;
+                schema: v.OptionalSchema<v.PicklistSchema<["thresholds", "always", "never"], undefined>, undefined>;
+                source: v.OptionalSchema<v.PicklistSchema<["thresholds", "always", "never"], undefined>, undefined>;
+                test: v.OptionalSchema<v.PicklistSchema<["thresholds", "always", "never"], undefined>, undefined>;
+            };
+            readonly "~standard": v.StandardProps<{
+                config?: "always" | "never" | "thresholds" | undefined;
+                dependency?: "always" | "never" | "thresholds" | undefined;
+                docs?: "always" | "never" | "thresholds" | undefined;
+                schema?: "always" | "never" | "thresholds" | undefined;
+                source?: "always" | "never" | "thresholds" | undefined;
+                test?: "always" | "never" | "thresholds" | undefined;
+            }, {
+                config?: "always" | "never" | "thresholds" | undefined;
+                dependency?: "always" | "never" | "thresholds" | undefined;
+                docs?: "always" | "never" | "thresholds" | undefined;
+                schema?: "always" | "never" | "thresholds" | undefined;
+                source?: "always" | "never" | "thresholds" | undefined;
+                test?: "always" | "never" | "thresholds" | undefined;
+            }>;
+            readonly "~run": (dataset: v.UnknownDataset, config: v.Config<v.BaseIssue<unknown>>) => v.OutputDataset<{
+                config?: "always" | "never" | "thresholds" | undefined;
+                dependency?: "always" | "never" | "thresholds" | undefined;
+                docs?: "always" | "never" | "thresholds" | undefined;
+                schema?: "always" | "never" | "thresholds" | undefined;
+                source?: "always" | "never" | "thresholds" | undefined;
+                test?: "always" | "never" | "thresholds" | undefined;
+            }, v.PicklistIssue | v.StrictObjectIssue>;
+            readonly "~types"?: {
+                readonly input: {
+                    config?: "always" | "never" | "thresholds" | undefined;
+                    dependency?: "always" | "never" | "thresholds" | undefined;
+                    docs?: "always" | "never" | "thresholds" | undefined;
+                    schema?: "always" | "never" | "thresholds" | undefined;
+                    source?: "always" | "never" | "thresholds" | undefined;
+                    test?: "always" | "never" | "thresholds" | undefined;
+                };
+                readonly output: {
+                    config?: "always" | "never" | "thresholds" | undefined;
+                    dependency?: "always" | "never" | "thresholds" | undefined;
+                    docs?: "always" | "never" | "thresholds" | undefined;
+                    schema?: "always" | "never" | "thresholds" | undefined;
+                    source?: "always" | "never" | "thresholds" | undefined;
+                    test?: "always" | "never" | "thresholds" | undefined;
+                };
+                readonly issue: v.PicklistIssue | v.StrictObjectIssue;
+            } | undefined;
+        }, {}>;
         readonly isDefault: v.OptionalSchema<v.BooleanSchema<undefined>, false>;
     }, undefined>;
     readonly responsesByStatusCode: {
@@ -122,6 +240,65 @@ export declare const createRiskPolicyContract: {
                 readonly minImpact: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 1, undefined>]>, undefined>;
                 readonly onMissingEstimate: v.OptionalSchema<v.PicklistSchema<["run", "skip"], undefined>, "run">;
             }, undefined>, undefined>, undefined>;
+            readonly classRules: Omit<v.StrictObjectSchema<{
+                config: v.PicklistSchema<["thresholds", "always", "never"], undefined>;
+                dependency: v.PicklistSchema<["thresholds", "always", "never"], undefined>;
+                docs: v.PicklistSchema<["thresholds", "always", "never"], undefined>;
+                schema: v.PicklistSchema<["thresholds", "always", "never"], undefined>;
+                source: v.PicklistSchema<["thresholds", "always", "never"], undefined>;
+                test: v.PicklistSchema<["thresholds", "always", "never"], undefined>;
+            }, undefined>, "entries" | "~run" | "~standard" | "~types"> & {
+                readonly entries: {
+                    config: v.OptionalSchema<v.PicklistSchema<["thresholds", "always", "never"], undefined>, undefined>;
+                    dependency: v.OptionalSchema<v.PicklistSchema<["thresholds", "always", "never"], undefined>, undefined>;
+                    docs: v.OptionalSchema<v.PicklistSchema<["thresholds", "always", "never"], undefined>, undefined>;
+                    schema: v.OptionalSchema<v.PicklistSchema<["thresholds", "always", "never"], undefined>, undefined>;
+                    source: v.OptionalSchema<v.PicklistSchema<["thresholds", "always", "never"], undefined>, undefined>;
+                    test: v.OptionalSchema<v.PicklistSchema<["thresholds", "always", "never"], undefined>, undefined>;
+                };
+                readonly "~standard": v.StandardProps<{
+                    config?: "always" | "never" | "thresholds" | undefined;
+                    dependency?: "always" | "never" | "thresholds" | undefined;
+                    docs?: "always" | "never" | "thresholds" | undefined;
+                    schema?: "always" | "never" | "thresholds" | undefined;
+                    source?: "always" | "never" | "thresholds" | undefined;
+                    test?: "always" | "never" | "thresholds" | undefined;
+                }, {
+                    config?: "always" | "never" | "thresholds" | undefined;
+                    dependency?: "always" | "never" | "thresholds" | undefined;
+                    docs?: "always" | "never" | "thresholds" | undefined;
+                    schema?: "always" | "never" | "thresholds" | undefined;
+                    source?: "always" | "never" | "thresholds" | undefined;
+                    test?: "always" | "never" | "thresholds" | undefined;
+                }>;
+                readonly "~run": (dataset: v.UnknownDataset, config: v.Config<v.BaseIssue<unknown>>) => v.OutputDataset<{
+                    config?: "always" | "never" | "thresholds" | undefined;
+                    dependency?: "always" | "never" | "thresholds" | undefined;
+                    docs?: "always" | "never" | "thresholds" | undefined;
+                    schema?: "always" | "never" | "thresholds" | undefined;
+                    source?: "always" | "never" | "thresholds" | undefined;
+                    test?: "always" | "never" | "thresholds" | undefined;
+                }, v.PicklistIssue | v.StrictObjectIssue>;
+                readonly "~types"?: {
+                    readonly input: {
+                        config?: "always" | "never" | "thresholds" | undefined;
+                        dependency?: "always" | "never" | "thresholds" | undefined;
+                        docs?: "always" | "never" | "thresholds" | undefined;
+                        schema?: "always" | "never" | "thresholds" | undefined;
+                        source?: "always" | "never" | "thresholds" | undefined;
+                        test?: "always" | "never" | "thresholds" | undefined;
+                    };
+                    readonly output: {
+                        config?: "always" | "never" | "thresholds" | undefined;
+                        dependency?: "always" | "never" | "thresholds" | undefined;
+                        docs?: "always" | "never" | "thresholds" | undefined;
+                        schema?: "always" | "never" | "thresholds" | undefined;
+                        source?: "always" | "never" | "thresholds" | undefined;
+                        test?: "always" | "never" | "thresholds" | undefined;
+                    };
+                    readonly issue: v.PicklistIssue | v.StrictObjectIssue;
+                } | undefined;
+            };
             readonly isDefault: v.BooleanSchema<undefined>;
             readonly version: v.OptionalSchema<v.NumberSchema<undefined>, undefined>;
             readonly createdAt: v.NumberSchema<undefined>;
@@ -156,6 +333,65 @@ export declare const updateRiskPolicyContract: {
             readonly minImpact: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 1, undefined>]>, undefined>;
             readonly onMissingEstimate: v.OptionalSchema<v.PicklistSchema<["run", "skip"], undefined>, "run">;
         }, undefined>, undefined>, undefined>;
+        readonly classRules: v.OptionalSchema<Omit<v.StrictObjectSchema<{
+            config: v.PicklistSchema<["thresholds", "always", "never"], undefined>;
+            dependency: v.PicklistSchema<["thresholds", "always", "never"], undefined>;
+            docs: v.PicklistSchema<["thresholds", "always", "never"], undefined>;
+            schema: v.PicklistSchema<["thresholds", "always", "never"], undefined>;
+            source: v.PicklistSchema<["thresholds", "always", "never"], undefined>;
+            test: v.PicklistSchema<["thresholds", "always", "never"], undefined>;
+        }, undefined>, "entries" | "~run" | "~standard" | "~types"> & {
+            readonly entries: {
+                config: v.OptionalSchema<v.PicklistSchema<["thresholds", "always", "never"], undefined>, undefined>;
+                dependency: v.OptionalSchema<v.PicklistSchema<["thresholds", "always", "never"], undefined>, undefined>;
+                docs: v.OptionalSchema<v.PicklistSchema<["thresholds", "always", "never"], undefined>, undefined>;
+                schema: v.OptionalSchema<v.PicklistSchema<["thresholds", "always", "never"], undefined>, undefined>;
+                source: v.OptionalSchema<v.PicklistSchema<["thresholds", "always", "never"], undefined>, undefined>;
+                test: v.OptionalSchema<v.PicklistSchema<["thresholds", "always", "never"], undefined>, undefined>;
+            };
+            readonly "~standard": v.StandardProps<{
+                config?: "always" | "never" | "thresholds" | undefined;
+                dependency?: "always" | "never" | "thresholds" | undefined;
+                docs?: "always" | "never" | "thresholds" | undefined;
+                schema?: "always" | "never" | "thresholds" | undefined;
+                source?: "always" | "never" | "thresholds" | undefined;
+                test?: "always" | "never" | "thresholds" | undefined;
+            }, {
+                config?: "always" | "never" | "thresholds" | undefined;
+                dependency?: "always" | "never" | "thresholds" | undefined;
+                docs?: "always" | "never" | "thresholds" | undefined;
+                schema?: "always" | "never" | "thresholds" | undefined;
+                source?: "always" | "never" | "thresholds" | undefined;
+                test?: "always" | "never" | "thresholds" | undefined;
+            }>;
+            readonly "~run": (dataset: v.UnknownDataset, config: v.Config<v.BaseIssue<unknown>>) => v.OutputDataset<{
+                config?: "always" | "never" | "thresholds" | undefined;
+                dependency?: "always" | "never" | "thresholds" | undefined;
+                docs?: "always" | "never" | "thresholds" | undefined;
+                schema?: "always" | "never" | "thresholds" | undefined;
+                source?: "always" | "never" | "thresholds" | undefined;
+                test?: "always" | "never" | "thresholds" | undefined;
+            }, v.PicklistIssue | v.StrictObjectIssue>;
+            readonly "~types"?: {
+                readonly input: {
+                    config?: "always" | "never" | "thresholds" | undefined;
+                    dependency?: "always" | "never" | "thresholds" | undefined;
+                    docs?: "always" | "never" | "thresholds" | undefined;
+                    schema?: "always" | "never" | "thresholds" | undefined;
+                    source?: "always" | "never" | "thresholds" | undefined;
+                    test?: "always" | "never" | "thresholds" | undefined;
+                };
+                readonly output: {
+                    config?: "always" | "never" | "thresholds" | undefined;
+                    dependency?: "always" | "never" | "thresholds" | undefined;
+                    docs?: "always" | "never" | "thresholds" | undefined;
+                    schema?: "always" | "never" | "thresholds" | undefined;
+                    source?: "always" | "never" | "thresholds" | undefined;
+                    test?: "always" | "never" | "thresholds" | undefined;
+                };
+                readonly issue: v.PicklistIssue | v.StrictObjectIssue;
+            } | undefined;
+        }, undefined>;
         readonly isDefault: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
     }, undefined>;
     readonly responsesByStatusCode: {
@@ -202,6 +438,65 @@ export declare const updateRiskPolicyContract: {
                 readonly minImpact: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 1, undefined>]>, undefined>;
                 readonly onMissingEstimate: v.OptionalSchema<v.PicklistSchema<["run", "skip"], undefined>, "run">;
             }, undefined>, undefined>, undefined>;
+            readonly classRules: Omit<v.StrictObjectSchema<{
+                config: v.PicklistSchema<["thresholds", "always", "never"], undefined>;
+                dependency: v.PicklistSchema<["thresholds", "always", "never"], undefined>;
+                docs: v.PicklistSchema<["thresholds", "always", "never"], undefined>;
+                schema: v.PicklistSchema<["thresholds", "always", "never"], undefined>;
+                source: v.PicklistSchema<["thresholds", "always", "never"], undefined>;
+                test: v.PicklistSchema<["thresholds", "always", "never"], undefined>;
+            }, undefined>, "entries" | "~run" | "~standard" | "~types"> & {
+                readonly entries: {
+                    config: v.OptionalSchema<v.PicklistSchema<["thresholds", "always", "never"], undefined>, undefined>;
+                    dependency: v.OptionalSchema<v.PicklistSchema<["thresholds", "always", "never"], undefined>, undefined>;
+                    docs: v.OptionalSchema<v.PicklistSchema<["thresholds", "always", "never"], undefined>, undefined>;
+                    schema: v.OptionalSchema<v.PicklistSchema<["thresholds", "always", "never"], undefined>, undefined>;
+                    source: v.OptionalSchema<v.PicklistSchema<["thresholds", "always", "never"], undefined>, undefined>;
+                    test: v.OptionalSchema<v.PicklistSchema<["thresholds", "always", "never"], undefined>, undefined>;
+                };
+                readonly "~standard": v.StandardProps<{
+                    config?: "always" | "never" | "thresholds" | undefined;
+                    dependency?: "always" | "never" | "thresholds" | undefined;
+                    docs?: "always" | "never" | "thresholds" | undefined;
+                    schema?: "always" | "never" | "thresholds" | undefined;
+                    source?: "always" | "never" | "thresholds" | undefined;
+                    test?: "always" | "never" | "thresholds" | undefined;
+                }, {
+                    config?: "always" | "never" | "thresholds" | undefined;
+                    dependency?: "always" | "never" | "thresholds" | undefined;
+                    docs?: "always" | "never" | "thresholds" | undefined;
+                    schema?: "always" | "never" | "thresholds" | undefined;
+                    source?: "always" | "never" | "thresholds" | undefined;
+                    test?: "always" | "never" | "thresholds" | undefined;
+                }>;
+                readonly "~run": (dataset: v.UnknownDataset, config: v.Config<v.BaseIssue<unknown>>) => v.OutputDataset<{
+                    config?: "always" | "never" | "thresholds" | undefined;
+                    dependency?: "always" | "never" | "thresholds" | undefined;
+                    docs?: "always" | "never" | "thresholds" | undefined;
+                    schema?: "always" | "never" | "thresholds" | undefined;
+                    source?: "always" | "never" | "thresholds" | undefined;
+                    test?: "always" | "never" | "thresholds" | undefined;
+                }, v.PicklistIssue | v.StrictObjectIssue>;
+                readonly "~types"?: {
+                    readonly input: {
+                        config?: "always" | "never" | "thresholds" | undefined;
+                        dependency?: "always" | "never" | "thresholds" | undefined;
+                        docs?: "always" | "never" | "thresholds" | undefined;
+                        schema?: "always" | "never" | "thresholds" | undefined;
+                        source?: "always" | "never" | "thresholds" | undefined;
+                        test?: "always" | "never" | "thresholds" | undefined;
+                    };
+                    readonly output: {
+                        config?: "always" | "never" | "thresholds" | undefined;
+                        dependency?: "always" | "never" | "thresholds" | undefined;
+                        docs?: "always" | "never" | "thresholds" | undefined;
+                        schema?: "always" | "never" | "thresholds" | undefined;
+                        source?: "always" | "never" | "thresholds" | undefined;
+                        test?: "always" | "never" | "thresholds" | undefined;
+                    };
+                    readonly issue: v.PicklistIssue | v.StrictObjectIssue;
+                } | undefined;
+            };
             readonly isDefault: v.BooleanSchema<undefined>;
             readonly version: v.OptionalSchema<v.NumberSchema<undefined>, undefined>;
             readonly createdAt: v.NumberSchema<undefined>;
@@ -301,6 +596,65 @@ export declare const reseedRiskPolicyContract: {
                 readonly minImpact: v.OptionalSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 1, undefined>]>, undefined>;
                 readonly onMissingEstimate: v.OptionalSchema<v.PicklistSchema<["run", "skip"], undefined>, "run">;
             }, undefined>, undefined>, undefined>;
+            readonly classRules: Omit<v.StrictObjectSchema<{
+                config: v.PicklistSchema<["thresholds", "always", "never"], undefined>;
+                dependency: v.PicklistSchema<["thresholds", "always", "never"], undefined>;
+                docs: v.PicklistSchema<["thresholds", "always", "never"], undefined>;
+                schema: v.PicklistSchema<["thresholds", "always", "never"], undefined>;
+                source: v.PicklistSchema<["thresholds", "always", "never"], undefined>;
+                test: v.PicklistSchema<["thresholds", "always", "never"], undefined>;
+            }, undefined>, "entries" | "~run" | "~standard" | "~types"> & {
+                readonly entries: {
+                    config: v.OptionalSchema<v.PicklistSchema<["thresholds", "always", "never"], undefined>, undefined>;
+                    dependency: v.OptionalSchema<v.PicklistSchema<["thresholds", "always", "never"], undefined>, undefined>;
+                    docs: v.OptionalSchema<v.PicklistSchema<["thresholds", "always", "never"], undefined>, undefined>;
+                    schema: v.OptionalSchema<v.PicklistSchema<["thresholds", "always", "never"], undefined>, undefined>;
+                    source: v.OptionalSchema<v.PicklistSchema<["thresholds", "always", "never"], undefined>, undefined>;
+                    test: v.OptionalSchema<v.PicklistSchema<["thresholds", "always", "never"], undefined>, undefined>;
+                };
+                readonly "~standard": v.StandardProps<{
+                    config?: "always" | "never" | "thresholds" | undefined;
+                    dependency?: "always" | "never" | "thresholds" | undefined;
+                    docs?: "always" | "never" | "thresholds" | undefined;
+                    schema?: "always" | "never" | "thresholds" | undefined;
+                    source?: "always" | "never" | "thresholds" | undefined;
+                    test?: "always" | "never" | "thresholds" | undefined;
+                }, {
+                    config?: "always" | "never" | "thresholds" | undefined;
+                    dependency?: "always" | "never" | "thresholds" | undefined;
+                    docs?: "always" | "never" | "thresholds" | undefined;
+                    schema?: "always" | "never" | "thresholds" | undefined;
+                    source?: "always" | "never" | "thresholds" | undefined;
+                    test?: "always" | "never" | "thresholds" | undefined;
+                }>;
+                readonly "~run": (dataset: v.UnknownDataset, config: v.Config<v.BaseIssue<unknown>>) => v.OutputDataset<{
+                    config?: "always" | "never" | "thresholds" | undefined;
+                    dependency?: "always" | "never" | "thresholds" | undefined;
+                    docs?: "always" | "never" | "thresholds" | undefined;
+                    schema?: "always" | "never" | "thresholds" | undefined;
+                    source?: "always" | "never" | "thresholds" | undefined;
+                    test?: "always" | "never" | "thresholds" | undefined;
+                }, v.PicklistIssue | v.StrictObjectIssue>;
+                readonly "~types"?: {
+                    readonly input: {
+                        config?: "always" | "never" | "thresholds" | undefined;
+                        dependency?: "always" | "never" | "thresholds" | undefined;
+                        docs?: "always" | "never" | "thresholds" | undefined;
+                        schema?: "always" | "never" | "thresholds" | undefined;
+                        source?: "always" | "never" | "thresholds" | undefined;
+                        test?: "always" | "never" | "thresholds" | undefined;
+                    };
+                    readonly output: {
+                        config?: "always" | "never" | "thresholds" | undefined;
+                        dependency?: "always" | "never" | "thresholds" | undefined;
+                        docs?: "always" | "never" | "thresholds" | undefined;
+                        schema?: "always" | "never" | "thresholds" | undefined;
+                        source?: "always" | "never" | "thresholds" | undefined;
+                        test?: "always" | "never" | "thresholds" | undefined;
+                    };
+                    readonly issue: v.PicklistIssue | v.StrictObjectIssue;
+                } | undefined;
+            };
             readonly isDefault: v.BooleanSchema<undefined>;
             readonly version: v.OptionalSchema<v.NumberSchema<undefined>, undefined>;
             readonly createdAt: v.NumberSchema<undefined>;

package/dist/routes/merge.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"merge.d.ts","sourceRoot":"","sources":["../../src/routes/merge.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAqB,MAAM,yBAAyB,CAAA;AAC3E,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAa5B,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAInC,CAAA;AAEF,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAKnC,CAAA;AAEF,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAMnC,CAAA;AAEF,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAKnC,CAAA;AAEF;;;;;GAKG;AACH,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAMnC,CAAA"}
+{"version":3,"file":"merge.d.ts","sourceRoot":"","sources":["../../src/routes/merge.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAqB,MAAM,yBAAyB,CAAA;AAC3E,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAa5B,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAInC,CAAA;AAEF,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAKnC,CAAA;AAEF,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAMnC,CAAA;AAEF,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAKnC,CAAA;AAEF;;;;;GAKG;AACH,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAMnC,CAAA"}

package/dist/routes/mergeTrackRecord.d.ts

@@ -0,0 +1,113 @@
+import * as v from 'valibot';
+/**
+ * Per-change-class rollups for the workspace — ONE request returns every class, computed as a
+ * single SQL aggregate (`GROUP BY change_class` + conditional `SUM`s). The preset editor renders
+ * each class's rule next to these numbers, so it must never fan out one request per class.
+ */
+export declare const listMergeClassRollupsContract: {
+    readonly method: "get";
+    readonly pathResolver: () => string;
+    readonly responsesByStatusCode: {
+        readonly '4xx': v.ObjectSchema<{
+            readonly error: v.ObjectSchema<{
+                readonly code: v.StringSchema<undefined>;
+                readonly message: v.StringSchema<undefined>;
+                readonly details: v.OptionalSchema<v.UnknownSchema, undefined>;
+                readonly issues: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
+                    readonly path: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+                    readonly message: v.StringSchema<undefined>;
+                }, undefined>, undefined>, undefined>;
+            }, undefined>;
+        }, undefined>;
+        readonly '5xx': v.ObjectSchema<{
+            readonly error: v.ObjectSchema<{
+                readonly code: v.StringSchema<undefined>;
+                readonly message: v.StringSchema<undefined>;
+                readonly details: v.OptionalSchema<v.UnknownSchema, undefined>;
+                readonly issues: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
+                    readonly path: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+                    readonly message: v.StringSchema<undefined>;
+                }, undefined>, undefined>, undefined>;
+            }, undefined>;
+        }, undefined>;
+        readonly 200: v.ArraySchema<v.ObjectSchema<{
+            readonly changeClass: v.PicklistSchema<["docs", "test", "dependency", "config", "source", "schema", "unknown"], undefined>;
+            readonly total: v.NumberSchema<undefined>;
+            readonly merged: v.NumberSchema<undefined>;
+            readonly autoMerged: v.NumberSchema<undefined>;
+            readonly humanMerged: v.NumberSchema<undefined>;
+            readonly externalMerged: v.NumberSchema<undefined>;
+            readonly rejected: v.NumberSchema<undefined>;
+            readonly pendingReview: v.NumberSchema<undefined>;
+            readonly effort: v.ObjectSchema<{
+                readonly none: v.NumberSchema<undefined>;
+                readonly minor: v.NumberSchema<undefined>;
+                readonly major: v.NumberSchema<undefined>;
+                readonly untagged: v.NumberSchema<undefined>;
+            }, undefined>;
+        }, undefined>, undefined>;
+    };
+};
+/**
+ * Tag (or clear) the reviewer effort a human spent on a merged pull request. Deliberately a
+ * standalone route as well as an `act`-body field: an external merge (or the inspector's merge
+ * control) needs to tag a record with no notification act in flight.
+ */
+export declare const tagMergeReviewEffortContract: {
+    readonly method: "post";
+    readonly requestPathParamsSchema: v.ObjectSchema<{
+        recordId: v.StringSchema<undefined>;
+    }, undefined> & import("@toad-contracts/core").StandardObjectKeysV1<unknown, unknown>;
+    readonly pathResolver: ({ recordId }: {
+        recordId: string;
+    }) => string;
+    readonly requestBodySchema: v.ObjectSchema<{
+        readonly reviewEffort: v.NullableSchema<v.PicklistSchema<["none", "minor", "major"], undefined>, undefined>;
+    }, undefined>;
+    readonly responsesByStatusCode: {
+        readonly '4xx': v.ObjectSchema<{
+            readonly error: v.ObjectSchema<{
+                readonly code: v.StringSchema<undefined>;
+                readonly message: v.StringSchema<undefined>;
+                readonly details: v.OptionalSchema<v.UnknownSchema, undefined>;
+                readonly issues: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
+                    readonly path: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+                    readonly message: v.StringSchema<undefined>;
+                }, undefined>, undefined>, undefined>;
+            }, undefined>;
+        }, undefined>;
+        readonly '5xx': v.ObjectSchema<{
+            readonly error: v.ObjectSchema<{
+                readonly code: v.StringSchema<undefined>;
+                readonly message: v.StringSchema<undefined>;
+                readonly details: v.OptionalSchema<v.UnknownSchema, undefined>;
+                readonly issues: v.OptionalSchema<v.ArraySchema<v.ObjectSchema<{
+                    readonly path: v.OptionalSchema<v.StringSchema<undefined>, undefined>;
+                    readonly message: v.StringSchema<undefined>;
+                }, undefined>, undefined>, undefined>;
+            }, undefined>;
+        }, undefined>;
+        readonly 200: v.ObjectSchema<{
+            readonly id: v.StringSchema<undefined>;
+            readonly blockId: v.StringSchema<undefined>;
+            readonly executionId: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+            readonly changeClass: v.PicklistSchema<["docs", "test", "dependency", "config", "source", "schema", "unknown"], undefined>;
+            readonly changedFileCount: v.NullableSchema<v.NumberSchema<undefined>, undefined>;
+            readonly complexity: v.NullableSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 1, undefined>]>, undefined>;
+            readonly risk: v.NullableSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 1, undefined>]>, undefined>;
+            readonly impact: v.NullableSchema<v.SchemaWithPipe<readonly [v.NumberSchema<undefined>, v.MinValueAction<number, 0, undefined>, v.MaxValueAction<number, 1, undefined>]>, undefined>;
+            readonly riskPolicyId: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+            readonly riskPolicyName: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+            readonly decision: v.PicklistSchema<["pending_review", "auto_merged", "human_merged", "external_merged", "rejected"], undefined>;
+            readonly reviewEffort: v.NullableSchema<v.PicklistSchema<["none", "minor", "major"], undefined>, undefined>;
+            readonly prNumber: v.NullableSchema<v.NumberSchema<undefined>, undefined>;
+            readonly prUrl: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+            readonly repoId: v.NullableSchema<v.StringSchema<undefined>, undefined>;
+            readonly provider: v.NullableSchema<v.PicklistSchema<["github", "gitlab"], undefined>, undefined>;
+            readonly createdAt: v.NumberSchema<undefined>;
+            readonly resolvedAt: v.NullableSchema<v.NumberSchema<undefined>, undefined>;
+            readonly taggedAt: v.NullableSchema<v.NumberSchema<undefined>, undefined>;
+        }, undefined>;
+    };
+};
+//# sourceMappingURL=mergeTrackRecord.d.ts.map

package/dist/routes/mergeTrackRecord.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mergeTrackRecord.d.ts","sourceRoot":"","sources":["../../src/routes/mergeTrackRecord.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAgB5B;;;;GAIG;AACH,eAAO,MAAM,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAIxC,CAAA;AAEF;;;;GAIG;AACH,eAAO,MAAM,4BAA4B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAMvC,CAAA"}

package/dist/routes/mergeTrackRecord.js

@@ -0,0 +1,33 @@
+import { defineApiContract } from '@toad-contracts/valibot';
+import * as v from 'valibot';
+import { mergeClassRollupSchema, mergeTrackRecordSchema, tagReviewEffortSchema, } from '../mergeTrackRecord.js';
+import { errorResponses, singleStringParam } from './_shared.js';
+// ---------------------------------------------------------------------------
+// Merge track record route contracts. Mounted under `/workspaces/:workspaceId`,
+// so the paths here are relative to that prefix. See MergeTrackRecordController in
+// @cat-factory/server.
+// ---------------------------------------------------------------------------
+const recordIdParams = singleStringParam('recordId');
+/**
+ * Per-change-class rollups for the workspace — ONE request returns every class, computed as a
+ * single SQL aggregate (`GROUP BY change_class` + conditional `SUM`s). The preset editor renders
+ * each class's rule next to these numbers, so it must never fan out one request per class.
+ */
+export const listMergeClassRollupsContract = defineApiContract({
+    method: 'get',
+    pathResolver: () => '/merge-track-records/rollups',
+    responsesByStatusCode: { 200: v.array(mergeClassRollupSchema), ...errorResponses },
+});
+/**
+ * Tag (or clear) the reviewer effort a human spent on a merged pull request. Deliberately a
+ * standalone route as well as an `act`-body field: an external merge (or the inspector's merge
+ * control) needs to tag a record with no notification act in flight.
+ */
+export const tagMergeReviewEffortContract = defineApiContract({
+    method: 'post',
+    requestPathParamsSchema: recordIdParams,
+    pathResolver: ({ recordId }) => `/merge-track-records/${recordId}/effort`,
+    requestBodySchema: tagReviewEffortSchema,
+    responsesByStatusCode: { 200: mergeTrackRecordSchema, ...errorResponses },
+});
+//# sourceMappingURL=mergeTrackRecord.js.map

package/dist/routes/mergeTrackRecord.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mergeTrackRecord.js","sourceRoot":"","sources":["../../src/routes/mergeTrackRecord.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAA;AAC3D,OAAO,KAAK,CAAC,MAAM,SAAS,CAAA;AAC5B,OAAO,EACL,sBAAsB,EACtB,sBAAsB,EACtB,qBAAqB,GACtB,MAAM,wBAAwB,CAAA;AAC/B,OAAO,EAAE,cAAc,EAAE,iBAAiB,EAAE,MAAM,cAAc,CAAA;AAEhE,8EAA8E;AAC9E,gFAAgF;AAChF,mFAAmF;AACnF,uBAAuB;AACvB,8EAA8E;AAE9E,MAAM,cAAc,GAAG,iBAAiB,CAAC,UAAU,CAAC,CAAA;AAEpD;;;;GAIG;AACH,MAAM,CAAC,MAAM,6BAA6B,GAAG,iBAAiB,CAAC;IAC7D,MAAM,EAAE,KAAK;IACb,YAAY,EAAE,GAAG,EAAE,CAAC,8BAA8B;IAClD,qBAAqB,EAAE,EAAE,GAAG,EAAE,CAAC,CAAC,KAAK,CAAC,sBAAsB,CAAC,EAAE,GAAG,cAAc,EAAE;CACnF,CAAC,CAAA;AAEF;;;;GAIG;AACH,MAAM,CAAC,MAAM,4BAA4B,GAAG,iBAAiB,CAAC;IAC5D,MAAM,EAAE,MAAM;IACd,uBAAuB,EAAE,cAAc;IACvC,YAAY,EAAE,CAAC,EAAE,QAAQ,EAAE,EAAE,EAAE,CAAC,wBAAwB,QAAQ,SAAS;IACzE,iBAAiB,EAAE,qBAAqB;IACxC,qBAAqB,EAAE,EAAE,GAAG,EAAE,sBAAsB,EAAE,GAAG,cAAc,EAAE;CAC1E,CAAC,CAAA"}

package/dist/routes/notification-webhooks.d.ts

@@ -29,7 +29,7 @@ export declare const getNotificationWebhookContract: {
         }, undefined>;
         readonly 200: v.NullableSchema<v.ObjectSchema<{
             readonly url: v.StringSchema<undefined>;
-            readonly types: v.ArraySchema<v.PicklistSchema<["merge_review", "pipeline_complete", "ci_failed", "test_failed", "requirement_review", "clarity_review", "release_regression", "decision_required", "human_test_ready", "visual_confirmation_ready", "human_review", "followup_pending", "fork_decision_pending", "pr_review_ready", "initiative", "platform_health", "budget_paused", "key_drift"], undefined>, undefined>;
+            readonly types: v.ArraySchema<v.PicklistSchema<["merge_review", "pipeline_complete", "ci_failed", "test_failed", "requirement_review", "clarity_review", "release_regression", "decision_required", "human_test_ready", "visual_confirmation_ready", "human_review", "followup_pending", "fork_decision_pending", "pr_review_ready", "initiative", "platform_health", "budget_paused", "key_drift", "merge_tag_request"], undefined>, undefined>;
             readonly enabled: v.BooleanSchema<undefined>;
             readonly hasSecret: v.BooleanSchema<undefined>;
             readonly updatedAt: v.NumberSchema<undefined>;
@@ -42,7 +42,7 @@ export declare const putNotificationWebhookContract: {
     readonly pathResolver: () => string;
     readonly requestBodySchema: v.ObjectSchema<{
         readonly url: v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.UrlAction<string, undefined>, v.StartsWithAction<string, "https://", "The webhook endpoint must be an https:// URL">, v.MaxLengthAction<string, 2000, undefined>]>;
-        readonly types: v.OptionalSchema<v.ArraySchema<v.PicklistSchema<["merge_review", "pipeline_complete", "ci_failed", "test_failed", "requirement_review", "clarity_review", "release_regression", "decision_required", "human_test_ready", "visual_confirmation_ready", "human_review", "followup_pending", "fork_decision_pending", "pr_review_ready", "initiative", "platform_health", "budget_paused", "key_drift"], undefined>, undefined>, undefined>;
+        readonly types: v.OptionalSchema<v.ArraySchema<v.PicklistSchema<["merge_review", "pipeline_complete", "ci_failed", "test_failed", "requirement_review", "clarity_review", "release_regression", "decision_required", "human_test_ready", "visual_confirmation_ready", "human_review", "followup_pending", "fork_decision_pending", "pr_review_ready", "initiative", "platform_health", "budget_paused", "key_drift", "merge_tag_request"], undefined>, undefined>, undefined>;
         readonly enabled: v.OptionalSchema<v.BooleanSchema<undefined>, undefined>;
         readonly secret: v.OptionalSchema<v.SchemaWithPipe<readonly [v.StringSchema<undefined>, v.TrimAction, v.MinLengthAction<string, 16, undefined>, v.MaxLengthAction<string, 200, undefined>]>, undefined>;
     }, undefined>;
@@ -71,7 +71,7 @@ export declare const putNotificationWebhookContract: {
         }, undefined>;
         readonly 200: v.ObjectSchema<{
             readonly url: v.StringSchema<undefined>;
-            readonly types: v.ArraySchema<v.PicklistSchema<["merge_review", "pipeline_complete", "ci_failed", "test_failed", "requirement_review", "clarity_review", "release_regression", "decision_required", "human_test_ready", "visual_confirmation_ready", "human_review", "followup_pending", "fork_decision_pending", "pr_review_ready", "initiative", "platform_health", "budget_paused", "key_drift"], undefined>, undefined>;
+            readonly types: v.ArraySchema<v.PicklistSchema<["merge_review", "pipeline_complete", "ci_failed", "test_failed", "requirement_review", "clarity_review", "release_regression", "decision_required", "human_test_ready", "visual_confirmation_ready", "human_review", "followup_pending", "fork_decision_pending", "pr_review_ready", "initiative", "platform_health", "budget_paused", "key_drift", "merge_tag_request"], undefined>, undefined>;
             readonly enabled: v.BooleanSchema<undefined>;
             readonly hasSecret: v.BooleanSchema<undefined>;
             readonly updatedAt: v.NumberSchema<undefined>;