jev-recipes 0.5.2 → 0.6.0

package/dist/recipes/notice-facets/schema.d.ts

@@ -0,0 +1,95 @@
+import { z } from 'zod';
+export declare const noticeFacetsLabelSchema: z.ZodEnum<{
+    statesDeadline: "statesDeadline";
+    statesAction: "statesAction";
+    statesConsequence: "statesConsequence";
+    statesContact: "statesContact";
+    statesAppealRight: "statesAppealRight";
+}>;
+export declare const noticeFacetsInputSchema: z.ZodObject<{
+    notice: z.ZodString;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const noticeFacetsResultSchema: z.ZodObject<{
+    model: z.ZodString;
+    usage: z.ZodObject<{
+        input_tokens: z.ZodNumber;
+        output_tokens: z.ZodNumber;
+    }, z.core.$strip>;
+    status: z.ZodEnum<{
+        ready: "ready";
+        review: "review";
+    }>;
+    detected: z.ZodArray<z.ZodEnum<{
+        statesDeadline: "statesDeadline";
+        statesAction: "statesAction";
+        statesConsequence: "statesConsequence";
+        statesContact: "statesContact";
+        statesAppealRight: "statesAppealRight";
+    }>>;
+    labels: z.ZodObject<{
+        statesAction: z.ZodObject<{
+            status: z.ZodEnum<{
+                ready: "ready";
+                review: "review";
+            }>;
+            verdict: z.ZodEnum<{
+                present: "present";
+                absent: "absent";
+            }>;
+            probability: z.ZodNumber;
+            confidence: z.ZodNumber;
+        }, z.core.$strip>;
+        statesDeadline: z.ZodObject<{
+            status: z.ZodEnum<{
+                ready: "ready";
+                review: "review";
+            }>;
+            verdict: z.ZodEnum<{
+                present: "present";
+                absent: "absent";
+            }>;
+            probability: z.ZodNumber;
+            confidence: z.ZodNumber;
+        }, z.core.$strip>;
+        statesConsequence: z.ZodObject<{
+            status: z.ZodEnum<{
+                ready: "ready";
+                review: "review";
+            }>;
+            verdict: z.ZodEnum<{
+                present: "present";
+                absent: "absent";
+            }>;
+            probability: z.ZodNumber;
+            confidence: z.ZodNumber;
+        }, z.core.$strip>;
+        statesContact: z.ZodObject<{
+            status: z.ZodEnum<{
+                ready: "ready";
+                review: "review";
+            }>;
+            verdict: z.ZodEnum<{
+                present: "present";
+                absent: "absent";
+            }>;
+            probability: z.ZodNumber;
+            confidence: z.ZodNumber;
+        }, z.core.$strip>;
+        statesAppealRight: z.ZodObject<{
+            status: z.ZodEnum<{
+                ready: "ready";
+                review: "review";
+            }>;
+            verdict: z.ZodEnum<{
+                present: "present";
+                absent: "absent";
+            }>;
+            probability: z.ZodNumber;
+            confidence: z.ZodNumber;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type NoticeFacetsLabel = z.infer<typeof noticeFacetsLabelSchema>;
+export type NoticeFacetsInput = z.infer<typeof noticeFacetsInputSchema>;
+export type NoticeFacetsResult = z.infer<typeof noticeFacetsResultSchema>;

package/dist/recipes/notice-facets/schema.js

@@ -0,0 +1,23 @@
+import { z } from 'zod';
+import { labelCheckSchema, labelsResultSchema, nonEmptyText, probability, } from '../../src/schema.js';
+export const noticeFacetsLabelSchema = z.enum([
+    'statesAction',
+    'statesDeadline',
+    'statesConsequence',
+    'statesContact',
+    'statesAppealRight',
+]);
+export const noticeFacetsInputSchema = z.object({
+    notice: nonEmptyText,
+    minConfidence: probability.optional(),
+});
+export const noticeFacetsResultSchema = labelsResultSchema.extend({
+    detected: z.array(noticeFacetsLabelSchema),
+    labels: z.object({
+        statesAction: labelCheckSchema,
+        statesDeadline: labelCheckSchema,
+        statesConsequence: labelCheckSchema,
+        statesContact: labelCheckSchema,
+        statesAppealRight: labelCheckSchema,
+    }),
+});

package/dist/recipes/novelty-claim-level/demo.json

@@ -0,0 +1,18 @@
+{
+  "input": {
+    "statement": "To the best of our knowledge, this is the first study to demonstrate that the effect transfers across species, a result no existing theoretical framework predicted.",
+    "minConfidence": 0.8
+  },
+  "response": {
+    "model": "demo-fixture",
+    "answers": {
+      "score": {
+        "type": "score",
+        "score": 3.86,
+        "confidence": 0.9,
+        "probabilities": { "0": 0, "1": 0.01, "2": 0.02, "3": 0.07, "4": 0.9 }
+      }
+    },
+    "usage": { "input_tokens": 0, "output_tokens": 0 }
+  }
+}

package/dist/recipes/novelty-claim-level/index.d.ts

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { NoveltyClaimLevelInput, NoveltyClaimLevelResult } from './schema.js';
+export declare function noveltyClaimLevel(input: NoveltyClaimLevelInput, options?: RecipeOptions): Promise<NoveltyClaimLevelResult>;
+export { noveltyClaimLevelInputSchema, noveltyClaimLevelResultSchema, noveltyClaimLevelVerdictSchema, } from './schema.js';
+export type { NoveltyClaimLevelInput, NoveltyClaimLevelResult, NoveltyClaimLevelVerdict, } from './schema.js';

package/dist/recipes/novelty-claim-level/index.js

@@ -0,0 +1,18 @@
+import { evaluateScore } from '../../src/scores.js';
+import { noveltyClaimLevelInputSchema, noveltyClaimLevelResultSchema, noveltyClaimLevelVerdictSchema, } from './schema.js';
+export async function noveltyClaimLevel(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = noveltyClaimLevelInputSchema.parse(input);
+    const decision = await evaluateScore(state, 'How strongly does the wording of statement claim novelty for the contribution it describes? Judge only the strength of the novelty language: words such as extend, build on, new, novel, first, unprecedented, and phrases such as to our knowledge or no prior work. Do not judge whether the claim is true, how important the contribution is, or how confident the author sounds about the results.', [
+        'The statement describes the work without claiming it is new, such as a replication, a summary, or a description of method with no comparison to prior work.',
+        'The statement positions the work as an extension, refinement, or variant of prior work, using words such as extend, adapt, or build on.',
+        'The statement calls the contribution new or novel in some respect while acknowledging related prior work exists.',
+        'The statement claims a major advance or a new approach that departs from existing work, without claiming to be the first.',
+        'The statement claims the contribution is the first of its kind, unprecedented, or unaddressed by any prior work, often with phrases such as to our knowledge or no previous study.',
+    ], options);
+    return noveltyClaimLevelResultSchema.parse({
+        ...decision,
+        novelty: noveltyClaimLevelVerdictSchema.options[decision.level],
+        status: decision.confidence < minConfidence ? 'review' : 'ready',
+    });
+}
+export { noveltyClaimLevelInputSchema, noveltyClaimLevelResultSchema, noveltyClaimLevelVerdictSchema, } from './schema.js';

package/dist/recipes/novelty-claim-level/schema.d.ts

@@ -0,0 +1,37 @@
+import { z } from 'zod';
+export declare const noveltyClaimLevelVerdictSchema: z.ZodEnum<{
+    none: "none";
+    incremental: "incremental";
+    notable: "notable";
+    substantial: "substantial";
+    unprecedented: "unprecedented";
+}>;
+export declare const noveltyClaimLevelInputSchema: z.ZodObject<{
+    statement: z.ZodString;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const noveltyClaimLevelResultSchema: z.ZodObject<{
+    model: z.ZodString;
+    usage: z.ZodObject<{
+        input_tokens: z.ZodNumber;
+        output_tokens: z.ZodNumber;
+    }, z.core.$strip>;
+    status: z.ZodEnum<{
+        ready: "ready";
+        review: "review";
+    }>;
+    score: z.ZodNumber;
+    level: z.ZodNumber;
+    confidence: z.ZodNumber;
+    probabilities: z.ZodRecord<z.ZodString, z.ZodNumber>;
+    novelty: z.ZodEnum<{
+        none: "none";
+        incremental: "incremental";
+        notable: "notable";
+        substantial: "substantial";
+        unprecedented: "unprecedented";
+    }>;
+}, z.core.$strip>;
+export type NoveltyClaimLevelVerdict = z.infer<typeof noveltyClaimLevelVerdictSchema>;
+export type NoveltyClaimLevelInput = z.infer<typeof noveltyClaimLevelInputSchema>;
+export type NoveltyClaimLevelResult = z.infer<typeof noveltyClaimLevelResultSchema>;

package/dist/recipes/novelty-claim-level/schema.js

@@ -0,0 +1,16 @@
+import { z } from 'zod';
+import { nonEmptyText, probability, scoreResultSchema } from '../../src/schema.js';
+export const noveltyClaimLevelVerdictSchema = z.enum([
+    'none',
+    'incremental',
+    'notable',
+    'substantial',
+    'unprecedented',
+]);
+export const noveltyClaimLevelInputSchema = z.object({
+    statement: nonEmptyText,
+    minConfidence: probability.optional(),
+});
+export const noveltyClaimLevelResultSchema = scoreResultSchema.extend({
+    novelty: noveltyClaimLevelVerdictSchema,
+});

package/dist/recipes/objection-kind/demo.json

@@ -0,0 +1,30 @@
+{
+  "input": {
+    "message": "Thanks for the proposal. Honestly the numbers came in well above what we budgeted for this year, so unless there is room to move on the per-seat rate I don't think we can make it work.",
+    "context": "Reply from a prospect after receiving a quote for 25 seats."
+  },
+  "response": {
+    "model": "demo-fixture",
+    "usage": {
+      "input_tokens": 0,
+      "output_tokens": 0
+    },
+    "answers": {
+      "decision": {
+        "type": "choice",
+        "choice": "price",
+        "confidence": 0.9,
+        "probabilities": {
+          "price": 0.9,
+          "timing": 0.05,
+          "authority": 0.01,
+          "need": 0.01,
+          "trust": 0.01,
+          "competitor": 0.01,
+          "none": 0,
+          "unclear": 0.01
+        }
+      }
+    }
+  }
+}

package/dist/recipes/objection-kind/index.d.ts

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { ObjectionKindInput, ObjectionKindResult } from './schema.js';
+export declare function objectionKind(input: ObjectionKindInput, options?: RecipeOptions): Promise<ObjectionKindResult>;
+export { objectionKindInputSchema, objectionKindResultSchema, objectionKindVerdictSchema, } from './schema.js';
+export type { ObjectionKindInput, ObjectionKindResult, ObjectionKindVerdict } from './schema.js';

package/dist/recipes/objection-kind/index.js

@@ -0,0 +1,20 @@
+import { evaluateChoice } from '../../src/decisions.js';
+import { objectionKindInputSchema, objectionKindResultSchema } from './schema.js';
+export async function objectionKind(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = objectionKindInputSchema.parse(input);
+    const decision = await evaluateChoice(state, 'What primary sales objection does message raise, given any context? Judge the main reason the sender gives for not proceeding, not the tone or how firmly it is stated.', {
+        price: 'The sender objects to the cost, budget, or value for money.',
+        timing: 'The sender is not ready to proceed now and cites the timing or other priorities.',
+        authority: 'The sender says someone else must decide or approve before proceeding.',
+        need: 'The sender does not see a need for the product or believes the current approach is sufficient.',
+        trust: 'The sender doubts the vendor, the product, or the claims made about it.',
+        competitor: 'The sender prefers or is already using an alternative product or vendor.',
+        none: 'The message raises no objection to proceeding.',
+        unclear: 'The primary objection is not established by the supplied text.',
+    }, options);
+    return objectionKindResultSchema.parse({
+        ...decision,
+        status: decision.confidence < minConfidence || decision.verdict === 'unclear' ? 'review' : 'ready',
+    });
+}
+export { objectionKindInputSchema, objectionKindResultSchema, objectionKindVerdictSchema, } from './schema.js';

package/dist/recipes/objection-kind/schema.d.ts

@@ -0,0 +1,51 @@
+import { z } from 'zod';
+export declare const objectionKindVerdictSchema: z.ZodEnum<{
+    none: "none";
+    unclear: "unclear";
+    price: "price";
+    timing: "timing";
+    authority: "authority";
+    need: "need";
+    trust: "trust";
+    competitor: "competitor";
+}>;
+export declare const objectionKindInputSchema: z.ZodObject<{
+    message: z.ZodString;
+    context: z.ZodOptional<z.ZodString>;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const objectionKindResultSchema: z.ZodObject<{
+    model: z.ZodString;
+    usage: z.ZodObject<{
+        input_tokens: z.ZodNumber;
+        output_tokens: z.ZodNumber;
+    }, z.core.$strip>;
+    status: z.ZodEnum<{
+        ready: "ready";
+        review: "review";
+    }>;
+    verdict: z.ZodEnum<{
+        none: "none";
+        unclear: "unclear";
+        price: "price";
+        timing: "timing";
+        authority: "authority";
+        need: "need";
+        trust: "trust";
+        competitor: "competitor";
+    }>;
+    confidence: z.ZodNumber;
+    probabilities: z.ZodRecord<z.ZodEnum<{
+        none: "none";
+        unclear: "unclear";
+        price: "price";
+        timing: "timing";
+        authority: "authority";
+        need: "need";
+        trust: "trust";
+        competitor: "competitor";
+    }>, z.ZodNumber>;
+}, z.core.$strip>;
+export type ObjectionKindInput = z.infer<typeof objectionKindInputSchema>;
+export type ObjectionKindResult = z.infer<typeof objectionKindResultSchema>;
+export type ObjectionKindVerdict = z.infer<typeof objectionKindVerdictSchema>;

package/dist/recipes/objection-kind/schema.js

@@ -0,0 +1,23 @@
+import { z } from 'zod';
+import { decisionStatusSchema, nonEmptyText, probability, resultMetadataSchema, } from '../../src/schema.js';
+export const objectionKindVerdictSchema = z.enum([
+    'price',
+    'timing',
+    'authority',
+    'need',
+    'trust',
+    'competitor',
+    'none',
+    'unclear',
+]);
+export const objectionKindInputSchema = z.object({
+    message: nonEmptyText,
+    context: nonEmptyText.optional(),
+    minConfidence: probability.optional(),
+});
+export const objectionKindResultSchema = resultMetadataSchema.extend({
+    status: decisionStatusSchema,
+    verdict: objectionKindVerdictSchema,
+    confidence: probability,
+    probabilities: z.record(objectionKindVerdictSchema, probability),
+});

package/dist/recipes/objective-fit/demo.json

@@ -0,0 +1,12 @@
+{
+  "input": {
+    "objective": "Students will be able to apply Newton's second law to compute the net force on an object given its mass and acceleration.",
+    "question": "State Newton's second law of motion in words and give the name of the unit of force.",
+    "minConfidence": 0.8
+  },
+  "response": {
+    "model": "demo-fixture",
+    "answers": { "gate": { "type": "noul", "noul": 0.08 } },
+    "usage": { "input_tokens": 0, "output_tokens": 0 }
+  }
+}

package/dist/recipes/objective-fit/index.d.ts

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { ObjectiveFitInput, ObjectiveFitResult } from './schema.js';
+export declare function objectiveFit(input: ObjectiveFitInput, options?: RecipeOptions): Promise<ObjectiveFitResult>;
+export { objectiveFitInputSchema, objectiveFitResultSchema, objectiveFitVerdictSchema, } from './schema.js';
+export type { ObjectiveFitInput, ObjectiveFitResult, ObjectiveFitVerdict } from './schema.js';

package/dist/recipes/objective-fit/index.js

@@ -0,0 +1,15 @@
+import { evaluateGate } from '../../src/gates.js';
+import { objectiveFitInputSchema, objectiveFitResultSchema } from './schema.js';
+export async function objectiveFit(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = objectiveFitInputSchema.parse(input);
+    const decision = await evaluateGate(state, 'Does question assess the skill or knowledge named in objective, rather than something adjacent? A question assesses the objective when a correct answer requires the stated skill or knowledge at the stated level. It misses when it can be answered with recall, a different skill, or a lower cognitive level than objective names, or when it tests a related topic objective does not cover.', {
+        true: 'Answering the question correctly requires the skill or knowledge stated in the objective.',
+        false: 'The question can be answered without the stated skill or knowledge, or it tests an adjacent topic.',
+    }, options);
+    return objectiveFitResultSchema.parse({
+        ...decision,
+        verdict: decision.probability >= 0.5 ? 'assesses' : 'misses',
+        status: decision.confidence < minConfidence ? 'review' : 'ready',
+    });
+}
+export { objectiveFitInputSchema, objectiveFitResultSchema, objectiveFitVerdictSchema, } from './schema.js';

package/dist/recipes/objective-fit/schema.d.ts

@@ -0,0 +1,30 @@
+import { z } from 'zod';
+export declare const objectiveFitVerdictSchema: z.ZodEnum<{
+    misses: "misses";
+    assesses: "assesses";
+}>;
+export declare const objectiveFitInputSchema: z.ZodObject<{
+    objective: z.ZodString;
+    question: z.ZodString;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const objectiveFitResultSchema: z.ZodObject<{
+    model: z.ZodString;
+    usage: z.ZodObject<{
+        input_tokens: z.ZodNumber;
+        output_tokens: z.ZodNumber;
+    }, z.core.$strip>;
+    status: z.ZodEnum<{
+        ready: "ready";
+        review: "review";
+    }>;
+    probability: z.ZodNumber;
+    confidence: z.ZodNumber;
+    verdict: z.ZodEnum<{
+        misses: "misses";
+        assesses: "assesses";
+    }>;
+}, z.core.$strip>;
+export type ObjectiveFitVerdict = z.infer<typeof objectiveFitVerdictSchema>;
+export type ObjectiveFitInput = z.infer<typeof objectiveFitInputSchema>;
+export type ObjectiveFitResult = z.infer<typeof objectiveFitResultSchema>;

package/dist/recipes/objective-fit/schema.js

@@ -0,0 +1,11 @@
+import { z } from 'zod';
+import { gateResultSchema, nonEmptyText, probability } from '../../src/schema.js';
+export const objectiveFitVerdictSchema = z.enum(['assesses', 'misses']);
+export const objectiveFitInputSchema = z.object({
+    objective: nonEmptyText,
+    question: nonEmptyText,
+    minConfidence: probability.optional(),
+});
+export const objectiveFitResultSchema = gateResultSchema.extend({
+    verdict: objectiveFitVerdictSchema,
+});

package/dist/recipes/offer-terms-facets/demo.json

@@ -0,0 +1,17 @@
+{
+  "input": {
+    "offer": "Offer to purchase 118 Linden Court\n\nBuyers: Marcus and Dana Reyes\nPurchase price: $412,000\nFinancing: conventional 30-year loan, 20% down; pre-approval letter from Summit Federal attached.\nContingencies: home inspection within 10 days of acceptance; financing contingency through closing.\nClosing: on or before November 15, 2026, with possession at closing.\nInclusions: kitchen appliances and washer/dryer.\n\nThis offer expires at 6:00 PM on September 26, 2026.",
+    "minConfidence": 0.8
+  },
+  "response": {
+    "model": "demo-fixture",
+    "answers": {
+      "statesPrice": { "type": "noul", "noul": 0.98 },
+      "statesFinancing": { "type": "noul", "noul": 0.95 },
+      "statesContingencies": { "type": "noul", "noul": 0.94 },
+      "statesClosingDate": { "type": "noul", "noul": 0.93 },
+      "statesDeposit": { "type": "noul", "noul": 0.06 }
+    },
+    "usage": { "input_tokens": 0, "output_tokens": 0 }
+  }
+}

package/dist/recipes/offer-terms-facets/index.d.ts

@@ -0,0 +1,5 @@
+import type { RecipeOptions } from '../../src/schema.js';
+import type { OfferTermsFacetsInput, OfferTermsFacetsResult } from './schema.js';
+export declare function offerTermsFacets(input: OfferTermsFacetsInput, options?: RecipeOptions): Promise<OfferTermsFacetsResult>;
+export { offerTermsFacetsInputSchema, offerTermsFacetsResultSchema, offerTermsFacetsLabelSchema, } from './schema.js';
+export type { OfferTermsFacetsInput, OfferTermsFacetsResult, OfferTermsFacetsLabel, } from './schema.js';

package/dist/recipes/offer-terms-facets/index.js

@@ -0,0 +1,48 @@
+import { evaluateLabels, resolveLabels } from '../../src/labels.js';
+import { offerTermsFacetsInputSchema, offerTermsFacetsResultSchema } from './schema.js';
+export async function offerTermsFacets(input, options = {}) {
+    const { minConfidence = 0.8, ...state } = offerTermsFacetsInputSchema.parse(input);
+    const evaluation = await evaluateLabels(state, {
+        statesPrice: {
+            instruction: 'Does offer state a purchase price or a rent amount?',
+            criteria: {
+                true: 'The text gives a purchase price, a monthly or periodic rent, or an equivalent amount the offeror proposes to pay.',
+                false: 'The text does not state what the offeror proposes to pay; deposits or fees alone do not count.',
+            },
+        },
+        statesFinancing: {
+            instruction: 'Does offer state how the purchase or rent will be funded, such as cash, a loan type, a down payment, or a pre-approval?',
+            criteria: {
+                true: 'The text says the offer is cash, names a loan type or lender, states a down payment or loan amount, or mentions pre-approval or proof of funds.',
+                false: 'The text says nothing about how payment will be funded.',
+            },
+        },
+        statesContingencies: {
+            instruction: 'Does offer state conditions the deal depends on, such as inspection, financing, appraisal, or sale of another property, or expressly waive them?',
+            criteria: {
+                true: 'The text names at least one contingency or condition, or expressly states that the offer has none or waives them.',
+                false: 'The text does not mention any condition the offer depends on and does not say it is unconditional.',
+            },
+        },
+        statesClosingDate: {
+            instruction: 'Does offer state a closing date, a move-in date, a lease start date, or a timeframe that fixes one?',
+            criteria: {
+                true: 'The text gives a closing, possession, move-in, or lease start date, or a period such as a number of days from acceptance.',
+                false: 'The text does not say when closing or move-in would happen.',
+            },
+        },
+        statesDeposit: {
+            instruction: 'Does offer state an earnest money deposit, a security deposit, or a similar good-faith payment?',
+            criteria: {
+                true: 'The text states an earnest money amount, a security deposit, or another deposit to be paid with or after acceptance.',
+                false: 'The text does not mention any deposit or earnest money.',
+            },
+        },
+    }, options);
+    return offerTermsFacetsResultSchema.parse({
+        ...resolveLabels(evaluation.labels, minConfidence),
+        model: evaluation.model,
+        usage: evaluation.usage,
+    });
+}
+export { offerTermsFacetsInputSchema, offerTermsFacetsResultSchema, offerTermsFacetsLabelSchema, } from './schema.js';

package/dist/recipes/offer-terms-facets/schema.d.ts

@@ -0,0 +1,95 @@
+import { z } from 'zod';
+export declare const offerTermsFacetsLabelSchema: z.ZodEnum<{
+    statesPrice: "statesPrice";
+    statesFinancing: "statesFinancing";
+    statesContingencies: "statesContingencies";
+    statesClosingDate: "statesClosingDate";
+    statesDeposit: "statesDeposit";
+}>;
+export declare const offerTermsFacetsInputSchema: z.ZodObject<{
+    offer: z.ZodString;
+    minConfidence: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+export declare const offerTermsFacetsResultSchema: z.ZodObject<{
+    model: z.ZodString;
+    usage: z.ZodObject<{
+        input_tokens: z.ZodNumber;
+        output_tokens: z.ZodNumber;
+    }, z.core.$strip>;
+    status: z.ZodEnum<{
+        ready: "ready";
+        review: "review";
+    }>;
+    detected: z.ZodArray<z.ZodEnum<{
+        statesPrice: "statesPrice";
+        statesFinancing: "statesFinancing";
+        statesContingencies: "statesContingencies";
+        statesClosingDate: "statesClosingDate";
+        statesDeposit: "statesDeposit";
+    }>>;
+    labels: z.ZodObject<{
+        statesPrice: z.ZodObject<{
+            status: z.ZodEnum<{
+                ready: "ready";
+                review: "review";
+            }>;
+            verdict: z.ZodEnum<{
+                present: "present";
+                absent: "absent";
+            }>;
+            probability: z.ZodNumber;
+            confidence: z.ZodNumber;
+        }, z.core.$strip>;
+        statesFinancing: z.ZodObject<{
+            status: z.ZodEnum<{
+                ready: "ready";
+                review: "review";
+            }>;
+            verdict: z.ZodEnum<{
+                present: "present";
+                absent: "absent";
+            }>;
+            probability: z.ZodNumber;
+            confidence: z.ZodNumber;
+        }, z.core.$strip>;
+        statesContingencies: z.ZodObject<{
+            status: z.ZodEnum<{
+                ready: "ready";
+                review: "review";
+            }>;
+            verdict: z.ZodEnum<{
+                present: "present";
+                absent: "absent";
+            }>;
+            probability: z.ZodNumber;
+            confidence: z.ZodNumber;
+        }, z.core.$strip>;
+        statesClosingDate: z.ZodObject<{
+            status: z.ZodEnum<{
+                ready: "ready";
+                review: "review";
+            }>;
+            verdict: z.ZodEnum<{
+                present: "present";
+                absent: "absent";
+            }>;
+            probability: z.ZodNumber;
+            confidence: z.ZodNumber;
+        }, z.core.$strip>;
+        statesDeposit: z.ZodObject<{
+            status: z.ZodEnum<{
+                ready: "ready";
+                review: "review";
+            }>;
+            verdict: z.ZodEnum<{
+                present: "present";
+                absent: "absent";
+            }>;
+            probability: z.ZodNumber;
+            confidence: z.ZodNumber;
+        }, z.core.$strip>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export type OfferTermsFacetsLabel = z.infer<typeof offerTermsFacetsLabelSchema>;
+export type OfferTermsFacetsInput = z.infer<typeof offerTermsFacetsInputSchema>;
+export type OfferTermsFacetsResult = z.infer<typeof offerTermsFacetsResultSchema>;

package/dist/recipes/offer-terms-facets/schema.js

@@ -0,0 +1,23 @@
+import { z } from 'zod';
+import { labelCheckSchema, labelsResultSchema, nonEmptyText, probability, } from '../../src/schema.js';
+export const offerTermsFacetsLabelSchema = z.enum([
+    'statesPrice',
+    'statesFinancing',
+    'statesContingencies',
+    'statesClosingDate',
+    'statesDeposit',
+]);
+export const offerTermsFacetsInputSchema = z.object({
+    offer: nonEmptyText,
+    minConfidence: probability.optional(),
+});
+export const offerTermsFacetsResultSchema = labelsResultSchema.extend({
+    detected: z.array(offerTermsFacetsLabelSchema),
+    labels: z.object({
+        statesPrice: labelCheckSchema,
+        statesFinancing: labelCheckSchema,
+        statesContingencies: labelCheckSchema,
+        statesClosingDate: labelCheckSchema,
+        statesDeposit: labelCheckSchema,
+    }),
+});