@recipe-book/core 0.0.3 → 0.1.1

package/dist/index.d.ts

@@ -1,5 +1,994 @@
-export { RecipeUtils } from './lib/recipe.js';
-export { UnitUtils } from './lib/unit.js';
-export { IngredientUtils } from './lib/ingredient.js';
-export { ConversionTables, GlobalRecipeConfig, Ingredient, IngredientAmount, Instruction, Recipe, RecipeConfig, Unit, UnitAbbreviation, UnitKey, UnitName } from './types.js';
-import './const/unit.js';
+import { Q as Quantity, P as ParseResult, R as Recipe, U as UnitAlias, S as System, I as Ingredient, a as Servings, Y as Yield, b as Step, A as Amount, c as Range, d as UnitId, e as UnitIdOf, f as UnitDefinition } from './types-BknM8KOd.js';
+export { C as CustomTime, D as Dimension, E as Equipment, g as IngredientSection, N as Note, h as Nutrition, i as RecipeBookError, j as RecipeBookErrorCode, k as RecipeIssue, l as RecipeIssueCode, m as RecipeValidationError, n as StepSection, T as Times, V as ValidationErrorCode, o as isRecipeBookError, u as units } from './types-BknM8KOd.js';
+
+/**
+ * An ingredient read from a line of text. It has no `id`, so pass it through
+ * `parseRecipe` before resolving it.
+ */
+type IngredientLine = {
+    name: string;
+    plural?: string | undefined;
+    quantity?: Quantity | undefined;
+    equivalents?: Quantity[] | undefined;
+    note?: string | undefined;
+    optional?: boolean | undefined;
+};
+/**
+ * Parses an ingredient line, such as `'1 ½ cups (190 g) flour, sifted'`, into
+ * ingredient input. Never throws. Pass the result through `parseRecipe` before
+ * resolving, or pass this function to `parseRecipe` as
+ * `{ parseIngredientLine }` to put lines in recipe input.
+ *
+ * Reads a leading amount (`2`, `1–2`, `a`, `one`) and unit, and a second
+ * measure in parentheses that hold nothing but measures, or after a slash or
+ * semicolon, as `equivalents`. With no amount, a unit before "of" reads as 1
+ * when it starts the line, after any leading "optional" and any space or
+ * colon, or "(optional)" and any space, and after any size word such as
+ * "big", so `'tsp. of salt'` gets `quantity: { amount: 1, unit: 'tsp' }` and
+ * `'big pinch of salt'` gets `quantity: { amount: 1, unit: 'pinch' }` and
+ * `note: 'big'`, but `'Optional - pinch of salt'` gets none. With no
+ * leading amount or unit, the first measure in parentheses that hold nothing
+ * but measures is the `quantity` instead, so `'Butter (100g)'` gets
+ * `quantity: { amount: 100, unit: 'g' }`. Measures after a leading "optional"
+ * in parentheses are read the same way, except straight after the amount,
+ * where the first is dropped (`'2 (optional, 15 oz) cans beans'`). A measure
+ * in the same dimension, mass or volume, after "plus", "and" or "+", or
+ * straight after the first, is added to it (`'1 lb 2 oz flour'` is 1.125 lb).
+ * In parentheses, any other sum (across dimensions, in count units such as
+ * "pinch", or of three measures) makes every measure in them part of the note
+ * (`'1 cup (8 oz + 1 tbsp) milk'`).
+ * With no leading amount or unit, an amount and unit after the name and a
+ * colon are read when nothing else follows but a note after a comma, so
+ * `'nagaimo: 160 g, grated'` gets `name: 'nagaimo'`,
+ * `quantity: { amount: 160, unit: 'g' }` and `note: 'grated'`. A name with a
+ * digit, or that starts with the word "for", "to", "a", "an", "yield",
+ * "yields" or "total", isn't read that way, and neither is one that is just
+ * "makes", "serves", "serving", "servings", "serving size", "protein",
+ * "carbs", "carbohydrate", "carbohydrates", "fiber", "fibre", "sodium",
+ * "cholesterol", "saturated fat" or "fat". So `'For the sauce: 1 cup'` and
+ * `'Protein: 12 g'` keep the whole line as the name, but
+ * `'Protein powder: 30 g'` gets `name: 'Protein powder'`.
+ * It also reads a note after the first comma outside parentheses that doesn't
+ * follow "boneless" or "skinless", phrases such as "to taste", and "optional"
+ * at the start of the line or of text in parentheses (the innermost when they
+ * nest), or as its own comma-separated item after the first comma. After a
+ * leading "optional" and any space or colon, or "(optional)" and any space,
+ * the rest is read as if it were the whole line, so
+ * `'Optional - 2 cups flour'` gets `optional: true` and
+ * `name: '- 2 cups flour'` with no quantity. With a comma there, not even
+ * "optional" is read: `'optional, 2 cups flour'` becomes
+ * `{ name: 'optional, 2 cups flour' }` with a warning. Text in parentheses
+ * before the first comma that isn't a measure or a leading "optional"
+ * (only the innermost when they nest) is a note too, ahead of the text after
+ * the comma, so `'1 onion (diced), peeled'` gets `note: 'diced, peeled'`. When
+ * parentheses before the first comma nest, the outer ones stay in the name with
+ * their text, so `'2 onions (diced (fine)), peeled'` gets
+ * `name: 'onions (diced)'` and `note: 'fine, peeled'`, and
+ * `'115 g butter ((1/2 cup))'` gets `name: 'butter ()'`.
+ * A bare count gets a `plural` from the word before "of", a leading container
+ * such as "jars", or else the last word. There's none when that word gets no
+ * other form, as when it ends in parentheses (`'2 onions (diced (fine))'`),
+ * has no plural ending after a count above 1 or a range (`'12 shrimp'`), or
+ * ends in "s" after a count of 1 or less (`'1 eggs'`, `'½ onions'`). A
+ * line it can't read becomes `{ name: line }` with a warning; only blank text
+ * or a value that isn't a string is an error.
+ *
+ * @example
+ * parseIngredientLine('1 ½ cups (190 g) flour, sifted').data
+ * // { name: 'flour', quantity: { amount: 1.5, unit: 'cup' }, equivalents: [{ amount: 190, unit: 'g' }], note: 'sifted' }
+ * parseIngredientLine('2 large eggs').data // { name: 'large egg', plural: 'large eggs', quantity: { amount: 2 } }
+ */
+declare function parseIngredientLine(text: string): ParseResult<IngredientLine>;
+
+/**
+ * Validates and normalizes recipe data: resolves unit aliases, parses quantity
+ * text and ISO 8601 durations, groups items into sections, derives ids, and
+ * infers the source system. Accepts `unknown`, so JSON needs no cast, and reads
+ * only an object's own fields. Never throws for bad data; an error thrown by a
+ * getter or proxy in the input passes through.
+ *
+ * Unknown fields, duplicate ids, missing or empty `ingredients` or `steps`, and
+ * empty sections are warnings and don't fail the parse. Each issue has the path
+ * of the value it is about.
+ *
+ * @example
+ * import { parseRecipe } from '@recipe-book/core'
+ *
+ * const result = parseRecipe({
+ *   name: 'Pancakes',
+ *   ingredients: [{ name: 'flour', quantity: '1 ½ cups' }],
+ *   steps: ['Whisk the batter.'],
+ * })
+ * result.success && result.data.ingredients[0]?.items[0]?.quantity // { amount: 1.5, unit: 'cup' }
+ *
+ * @example
+ * import { parseRecipe } from '@recipe-book/core'
+ *
+ * const result = parseRecipe({
+ *   name: 'Pancakes',
+ *   ingredients: [{ name: 'flour', quantity: '1 ½ cupz' }],
+ *   steps: ['Whisk the batter.'],
+ * })
+ * if (!result.success) {
+ *   console.error(result.error.message)
+ *   // "Pancakes" has 1 problem:
+ *   //   ✖ ingredients[0].quantity  Unknown unit "cupz". Did you mean "cups"?
+ *   // See https://recipe-book.siraj.page/errors/invalid_recipe
+ * }
+ */
+declare function parseRecipe(input: unknown): ParseResult<Recipe>;
+/**
+ * Parses recipe data as `parseRecipe(input)` does, and reads ingredients
+ * written as text with `options.parseIngredientLine`. Without it, a text
+ * ingredient is an `invalid_type` error.
+ *
+ * @throws {RecipeBookError} `invalid_argument` when
+ * `options.parseIngredientLine` is present but isn't a function.
+ *
+ * @example
+ * import { parseIngredientLine, parseRecipe } from '@recipe-book/core'
+ *
+ * const result = parseRecipe(
+ *   { name: 'Toast', ingredients: ['2 slices bread', '1 tbsp butter, softened'] },
+ *   { parseIngredientLine },
+ * )
+ * result.success && result.data.ingredients[0]?.items[1] // { id: 'butter', name: 'butter', quantity: { amount: 1, unit: 'tbsp' }, equivalents: [], note: 'softened', optional: false }
+ */
+declare function parseRecipe(input: unknown, options: ParseRecipeOptions | undefined): ParseResult<Recipe>;
+/** Options for `parseRecipe`. */
+type ParseRecipeOptions = {
+    /**
+     * Reads ingredients written as text, such as `'2 cups flour'`. Pass
+     * `parseIngredientLine`. Without it, a text ingredient is an `invalid_type` error.
+     * A function of your own must return what `parseIngredientLine` returns.
+     */
+    parseIngredientLine?: ((text: string) => ParseResult<IngredientLine>) | undefined;
+};
+
+/**
+ * Parses quantity text, such as `'1 ½ cups'`, `'2-3 tbsp'`, `'a pinch'`, or
+ * `'3'` for a bare count. Never throws.
+ *
+ * Accepts whole numbers, decimals, fractions (`1/2`, `½`, also with the
+ * fraction slash `⁄`), mixed numbers (`1 1/2`, `1½`) and ranges (`2-3`, `2–3`,
+ * `2 to 3`), each followed by an optional unit alias, and `a` or `an` for 1
+ * before a unit alias, as in `'a pinch'`.
+ *
+ * @example
+ * parseQuantity('1 ½ cups') // { success: true, data: { amount: 1.5, unit: 'cup' }, warnings: [] }
+ *
+ * const result = parseQuantity('2 cupz')
+ * if (!result.success) {
+ *   result.error.message // '"2 cupz" has 1 problem:\n  ✖ (root)  Unknown unit "cupz". Did you mean "cups"?\nSee https://recipe-book.siraj.page/errors/invalid_quantity'
+ * }
+ */
+declare function parseQuantity(text: string): ParseResult<Quantity>;
+
+/**
+ * The Standard Schema v1 interface (https://standardschema.dev), copied from
+ * `@standard-schema/spec` 1.1.0 as the spec recommends so core stays
+ * dependency-free. `test/schema.test.ts` checks that it stays compatible.
+ */
+interface StandardSchemaV1<Input = unknown, Output = Input> {
+    readonly '~standard': StandardSchemaV1.Props<Input, Output>;
+}
+declare namespace StandardSchemaV1 {
+    interface Props<Input = unknown, Output = Input> extends StandardTypedV1.Props<Input, Output> {
+        readonly validate: (value: unknown, options?: StandardSchemaV1.Options) => Result<Output> | Promise<Result<Output>>;
+    }
+    type Result<Output> = SuccessResult<Output> | FailureResult;
+    interface SuccessResult<Output> {
+        readonly value: Output;
+        readonly issues?: undefined;
+    }
+    interface Options {
+        readonly libraryOptions?: Record<string, unknown> | undefined;
+    }
+    interface FailureResult {
+        readonly issues: ReadonlyArray<Issue>;
+    }
+    interface Issue {
+        readonly message: string;
+        readonly path?: ReadonlyArray<PropertyKey | PathSegment> | undefined;
+    }
+    interface PathSegment {
+        readonly key: PropertyKey;
+    }
+    type Types<Input = unknown, Output = Input> = StandardTypedV1.Types<Input, Output>;
+    type InferInput<Schema extends StandardTypedV1> = StandardTypedV1.InferInput<Schema>;
+    type InferOutput<Schema extends StandardTypedV1> = StandardTypedV1.InferOutput<Schema>;
+}
+interface StandardTypedV1<Input = unknown, Output = Input> {
+    readonly '~standard': StandardTypedV1.Props<Input, Output>;
+}
+declare namespace StandardTypedV1 {
+    interface Props<Input = unknown, Output = Input> {
+        readonly version: 1;
+        readonly vendor: string;
+        readonly types?: Types<Input, Output> | undefined;
+    }
+    interface Types<Input = unknown, Output = Input> {
+        readonly input: Input;
+        readonly output: Output;
+    }
+    type InferInput<Schema extends StandardTypedV1> = NonNullable<Schema['~standard']['types']>['input'];
+    type InferOutput<Schema extends StandardTypedV1> = NonNullable<Schema['~standard']['types']>['output'];
+}
+
+type Digit = '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9';
+type VulgarFraction = '¼' | '½' | '¾' | '⅐' | '⅑' | '⅒' | '⅓' | '⅔' | '⅕' | '⅖' | '⅗' | '⅘' | '⅙' | '⅚' | '⅛' | '⅜' | '⅝' | '⅞';
+/**
+ * Quantity text. It must end in a known unit alias, optionally followed by a
+ * period, or in a digit or fraction for a bare count, so a misspelled unit is a
+ * compile error. The alias must be in its listed case: `'2 Tbsp'` doesn't
+ * type-check, though `parseRecipe` reads it. `parseRecipe` checks the full
+ * grammar at runtime; see `parseQuantity`.
+ *
+ * @example
+ * import type { QuantityString } from '@recipe-book/core'
+ *
+ * const ok: QuantityString[] = ['1 ½ cups', '2-3 tbsp.', 'a pinch', '250g', '3']
+ * // @ts-expect-error: 'cupz' is not a unit
+ * const typo: QuantityString = '2 cupz'
+ */
+type QuantityString = `${string}${Digit | VulgarFraction}` | `${string} ${UnitAlias}` | `${string} ${UnitAlias}.` | `${number}${UnitAlias}` | `${number}${UnitAlias}.`;
+/** A quantity as authors write it: text, a bare count, or an object with a unit alias. */
+type QuantityInput = QuantityString | number | {
+    amount: number | {
+        min: number;
+        max: number;
+    };
+    unit?: UnitAlias | `${UnitAlias}.` | undefined;
+};
+/** Minutes, or an ISO 8601 duration such as `'PT1H30M'`. */
+type DurationInput = number | `P${string}`;
+/**
+ * An ingredient as authors write it. `id` is derived from `name` when absent,
+ * and `optional` defaults to `false`.
+ *
+ * @example
+ * import type { IngredientInput } from '@recipe-book/core'
+ *
+ * const butter: IngredientInput = { name: 'butter', quantity: '2 tbsp', note: 'melted' }
+ */
+type IngredientInput = {
+    id?: string | undefined;
+    name: string;
+    plural?: string | undefined;
+    quantity?: QuantityInput | undefined;
+    equivalents?: readonly QuantityInput[] | undefined;
+    note?: string | undefined;
+    /** An http or https URL, or a relative one, including protocol-relative `//host/path`. */
+    url?: string | undefined;
+    optional?: boolean | undefined;
+};
+/** A group of ingredients. Any entry with `items` is read as a section; sections can't be nested. */
+type IngredientSectionInput<Line extends string = never> = {
+    id?: string | undefined;
+    title?: string | undefined;
+    items: readonly (Line | IngredientInput)[];
+};
+/** A step with a short `name` or an image. A plain string is a step with only `text`. */
+type StepInput = {
+    id?: string | undefined;
+    text: string;
+    name?: string | undefined;
+    /** An http or https URL, or a relative one, including protocol-relative `//host/path`. */
+    image?: string | undefined;
+};
+/** A group of steps, given as strings or `StepInput` objects. Sections can't be nested. */
+type StepSectionInput = {
+    id?: string | undefined;
+    title?: string | undefined;
+    items: readonly (string | StepInput)[];
+};
+/** A number of servings, range text such as `'4–6'`, or `{ amount, max }`. */
+type ServingsInput = number | string | {
+    amount: number;
+    max?: number | undefined;
+};
+/**
+ * What a batch makes: text such as `'24 cookies'` or `'2–3 loaves'`, or an
+ * object with the singular and plural. Text keeps its unit as written, so a
+ * yield that scales to 1 needs the object form to read "1 loaf". A yield needs
+ * a unit; use `ServingsInput` for a number of servings.
+ */
+type YieldInput = string | {
+    amount: number;
+    max?: number | undefined;
+    unit: string;
+    plural?: string | undefined;
+};
+/** Durations, each in minutes or as an ISO 8601 duration such as `'PT1H30M'`. */
+type TimesInput = {
+    prep?: DurationInput | undefined;
+    cook?: DurationInput | undefined;
+    total?: DurationInput | undefined;
+    custom?: readonly CustomTimeInput[] | undefined;
+};
+/** A named time, such as `{ label: 'Chill', minutes: 120 }` or `{ label: 'Rise', minutes: 'PT1H' }`. */
+type CustomTimeInput = {
+    id?: string | undefined;
+    label: string;
+    minutes: DurationInput;
+};
+/** A note with a title. A plain string is a note with only `text`. */
+type NoteInput = {
+    id?: string | undefined;
+    title?: string | undefined;
+    /** Plain text. Renderers show it as text, never as HTML. */
+    text: string;
+};
+/** A tool with details. A plain string is a tool with only a `name`. */
+type EquipmentInput = {
+    id?: string | undefined;
+    name: string;
+    /** Used when `quantity` is above 1: "2 baking sheets". */
+    plural?: string | undefined;
+    /** A whole number, such as `2` for two baking sheets. */
+    quantity?: number | undefined;
+    /** An http or https URL, or a relative one, including protocol-relative `//host/path`. */
+    url?: string | undefined;
+    note?: string | undefined;
+};
+/** A number in the nutrient's unit, or text with a unit, such as `'12 g'`. */
+type NutrientInput = number | string;
+/**
+ * Nutrition for one of the recipe's `servings`. Calories are in kcal, sodium
+ * and cholesterol in mg, and the rest in g. Text with another unit is
+ * converted: `'1046 kJ'` is 250 kcal, and sodium `'1.2 g'` is 1200 mg.
+ */
+type NutritionInput = {
+    servingSize?: string | undefined;
+    calories?: NutrientInput | undefined;
+    fat?: NutrientInput | undefined;
+    saturatedFat?: NutrientInput | undefined;
+    transFat?: NutrientInput | undefined;
+    unsaturatedFat?: NutrientInput | undefined;
+    carbohydrates?: NutrientInput | undefined;
+    sugar?: NutrientInput | undefined;
+    fiber?: NutrientInput | undefined;
+    protein?: NutrientInput | undefined;
+    sodium?: NutrientInput | undefined;
+    cholesterol?: NutrientInput | undefined;
+};
+/**
+ * A recipe as authors write it. Use `satisfies RecipeInput` for type checking,
+ * and `parseRecipe` to normalize it into a `Recipe`. Ingredients may be a flat
+ * list, sections, or a mix; steps may be strings, objects, or sections.
+ * `RecipeInput<string>` also allows ingredient lines, for input parsed with
+ * `{ parseIngredientLine }`.
+ *
+ * @example
+ * import type { RecipeInput } from '@recipe-book/core'
+ *
+ * export const pancakes = {
+ *   name: 'Buttermilk pancakes',
+ *   servings: 4,
+ *   ingredients: [
+ *     { name: 'all-purpose flour', quantity: '1 ½ cups', equivalents: ['190 g'] },
+ *     { name: 'egg', plural: 'eggs', quantity: 2 },
+ *   ],
+ *   steps: ['Whisk the dry ingredients.', 'Fold in the wet ingredients.'],
+ * } satisfies RecipeInput
+ *
+ * @example
+ * import { parseIngredientLine, parseRecipe, type RecipeInput } from '@recipe-book/core'
+ *
+ * export const toast = {
+ *   name: 'Buttered toast',
+ *   ingredients: ['2 slices bread', '3 tbsp butter, melted'],
+ * } satisfies RecipeInput<string>
+ * parseRecipe(toast, { parseIngredientLine })
+ */
+type RecipeInput<Line extends string = never> = {
+    id?: string | undefined;
+    name: string;
+    description?: string | undefined;
+    /** An http or https URL, or a relative one, including protocol-relative `//host/path`. */
+    image?: string | undefined;
+    servings?: ServingsInput | undefined;
+    yield?: YieldInput | undefined;
+    system?: System | undefined;
+    times?: TimesInput | undefined;
+    ingredients?: readonly (Line | IngredientInput | IngredientSectionInput<Line>)[] | undefined;
+    steps?: readonly (string | StepInput | StepSectionInput)[] | undefined;
+    notes?: readonly (string | NoteInput)[] | undefined;
+    equipment?: readonly (string | EquipmentInput)[] | undefined;
+    nutrition?: NutritionInput | undefined;
+};
+
+/**
+ * The type of {@link recipeSchema}: a Standard Schema v1 whose `validate`
+ * returns its result directly, never a promise. `RecipeSchema<string>`, from
+ * {@link createRecipeSchema}, also takes ingredient lines.
+ */
+interface RecipeSchema<Line extends string = never> extends StandardSchemaV1<RecipeInput<Line>, Recipe> {
+    readonly '~standard': {
+        readonly version: 1;
+        readonly vendor: string;
+        readonly validate: (value: unknown, options?: StandardSchemaV1.Options) => StandardSchemaV1.Result<Recipe>;
+        readonly types?: StandardSchemaV1.Types<RecipeInput<Line>, Recipe> | undefined;
+    };
+}
+/**
+ * `parseRecipe` as a [Standard Schema](https://standardschema.dev) v1, for
+ * libraries that accept one: tRPC, TanStack Form, react-hook-form, Hono, and
+ * others. Validation is synchronous, so `validate` returns its result
+ * directly. Only errors are reported as issues; warnings don't fail
+ * validation. It reads ingredient objects only; use
+ * {@link createRecipeSchema} for ingredient lines.
+ *
+ * @example
+ * import { recipeSchema } from '@recipe-book/core'
+ * import { initTRPC } from '@trpc/server'
+ *
+ * const t = initTRPC.create()
+ * export const appRouter = t.router({
+ *   saveRecipe: t.procedure.input(recipeSchema).mutation(({ input }) => input.id), // input: Recipe
+ * })
+ */
+declare const recipeSchema: RecipeSchema;
+/**
+ * Makes a schema like {@link recipeSchema} that parses with `options`. Pass
+ * `{ parseIngredientLine }` to accept ingredients written as text.
+ *
+ * @throws {RecipeBookError} `invalid_argument` when
+ * `options.parseIngredientLine` is present but isn't a function.
+ *
+ * @example
+ * import { createRecipeSchema, parseIngredientLine } from '@recipe-book/core'
+ * import { initTRPC } from '@trpc/server'
+ *
+ * const t = initTRPC.create()
+ * const recipeInput = createRecipeSchema({ parseIngredientLine })
+ * export const appRouter = t.router({
+ *   saveRecipe: t.procedure.input(recipeInput).mutation(({ input }) => input.id), // input: Recipe
+ * })
+ */
+declare function createRecipeSchema(options: ParseRecipeOptions): RecipeSchema<string>;
+
+/**
+ * Where a resolved quantity comes from: the ingredient's `quantity`, one of its
+ * `equivalents`, or a conversion into the display system. May grow in minor releases.
+ */
+type QuantityOrigin = 'authored' | 'equivalent' | 'converted';
+/** An ingredient, scaled and expressed in the display system. */
+type ResolvedIngredient = {
+    id: string;
+    /** The ingredient as authored, unscaled, not a copy; treat it as read-only. */
+    ingredient: Ingredient;
+    /**
+     * Absent for unquantified ingredients, such as "salt, to taste". May be the
+     * authored object; treat it as read-only.
+     */
+    quantity?: Quantity | undefined;
+    /** `'authored'` for unquantified ingredients. */
+    origin: QuantityOrigin;
+};
+/** What {@link resolveRecipe} returns: the recipe at a scale, in one system, unrounded. */
+type ResolvedRecipe = {
+    /** The recipe passed in, not a copy; treat it as read-only. */
+    recipe: Recipe;
+    /**
+     * The `scale` option, else `servings` divided by the scaling base. Always
+     * between 1e-6 and 1e6, and 1 when both options fall back.
+     */
+    scale: number;
+    /**
+     * The recipe's servings at this scale. At 1×, the authored servings. When
+     * the `servings` option sets a scale other than 1, exactly that number with
+     * no `max`; with `scale`, both ends of a range scale.
+     */
+    servings?: Servings | undefined;
+    /**
+     * The recipe's yield at this scale. At 1×, the authored yield. When the
+     * yield is the scaling base and the `servings` option sets a scale other
+     * than 1, exactly that number with no `max`; otherwise both ends of a range
+     * scale.
+     */
+    yield?: Yield | undefined;
+    system: System;
+    /**
+     * True when an ingredient's quantity has a unit that belongs to only one
+     * system. Step text isn't read; `segmentStepText` finds its temperatures.
+     */
+    canConvert: boolean;
+    ingredients: Array<{
+        id: string;
+        title?: string | undefined;
+        items: ResolvedIngredient[];
+    }>;
+    /** Steps numbered from 1, continuing across sections. */
+    steps: Array<{
+        id: string;
+        title?: string | undefined;
+        items: Array<Step & {
+            number: number;
+        }>;
+    }>;
+};
+/** Options for {@link resolveRecipe}. */
+type ResolveRecipeOptions = {
+    /**
+     * Scales by `servings / base`, where the base is the recipe's servings
+     * amount, else its yield amount, else 1. Defaults to the base. A value
+     * outside a millionth to a million times the base, or that isn't a number,
+     * also uses the default.
+     */
+    servings?: number | undefined;
+    /**
+     * A direct multiplier, for 1×, 2×, and 3× controls. Wins over `servings`.
+     * A value outside 1e-6 to 1e6, or that isn't a number, is ignored.
+     */
+    scale?: number | undefined;
+    /** Defaults to `recipe.system`, then `'metric'`. An unknown system also uses the default. */
+    system?: System | undefined;
+    /** Moves scaled amounts to a better unit on their own ladder (6 tsp to 2 tbsp). Default `true`. */
+    rebalance?: boolean | undefined;
+};
+/** Options for {@link resolveIngredient}. */
+type ResolveIngredientOptions = {
+    scale: number;
+    system: System;
+    /** Moves scaled amounts to a better unit on their own ladder (6 tsp to 2 tbsp). Default `true`. */
+    rebalance?: boolean | undefined;
+};
+/**
+ * Scales a recipe to a number of servings, or by a multiplier, and expresses
+ * each ingredient in a measurement system. Pure, and never throws for an
+ * unchanged recipe from `parseRecipe`: invalid options fall back to their
+ * defaults, and an error thrown by a getter or proxy in the options passes
+ * through. Nothing is rounded; format for display.
+ *
+ * Each ingredient uses the first of `[quantity, ...equivalents]` that is native to
+ * the system (a bare count is native to both), scaled. When none is, `quantity`
+ * is scaled, then converted with `toSystem`. Units never change dimension.
+ * At any scale but 1, the chosen quantity may move along its unit's ladder, so
+ * 3 tsp at 2× is 2 tbsp; pass `rebalance: false` to keep the chosen units.
+ *
+ * @example
+ * // Serves 4–6; flour is 1 ½ cups with a 190 g equivalent.
+ * const resolved = resolveRecipe(pancakes, { servings: 8, system: 'metric' })
+ * resolved.scale // 2
+ * resolved.servings // { amount: 8 }
+ * const flour = resolved.ingredients[0]?.items[0]
+ * flour?.quantity // { amount: 380, unit: 'g' }
+ * flour?.origin // 'equivalent'
+ *
+ * resolveRecipe(pancakes, { scale: 2 }).servings // { amount: 8, max: 12 }
+ */
+declare function resolveRecipe(recipe: Recipe, options?: ResolveRecipeOptions): ResolvedRecipe;
+/**
+ * Resolves one ingredient the way {@link resolveRecipe} does, at a raw
+ * scale factor. Unlike `resolveRecipe`, it doesn't limit the scale to
+ * 1e-6 to 1e6, so a huge scale can overflow an amount to `Infinity`, which
+ * the format functions reject.
+ *
+ * @throws {RecipeBookError} `invalid_argument` when `scale` is not a finite
+ *   number greater than 0, or `system` is not `'metric'` or `'us'`.
+ *
+ * @example
+ * // salt is 3 tsp.
+ * resolveIngredient(salt, { scale: 2, system: 'us' }).quantity // { amount: 2, unit: 'tbsp' }
+ */
+declare function resolveIngredient(ingredient: Ingredient, options: ResolveIngredientOptions): ResolvedIngredient;
+
+/** The amount type an operation returns for an input amount type. */
+type SameAmount<A extends Amount> = A extends number ? number : Range;
+
+/**
+ * Multiplies a quantity by `factor`. Both ends of a range scale, the unit is
+ * kept, and nothing is rounded.
+ *
+ * @throws {RecipeBookError} `invalid_argument` when `factor` is not a finite
+ *   number greater than 0, `quantity` isn't a quantity object, the amount is
+ *   not a finite number greater than 0 or a range of them, a range's `min`
+ *   isn't less than its `max`, or the quantity has `max` set, as a `Servings`
+ *   or `Yield` has. `resolveRecipe` scales those. The unit isn't checked.
+ *   Also thrown when an end times `factor` overflows to `Infinity` or
+ *   underflows to 0: past about 1.8e308, or below about 5e-324.
+ *
+ * @example
+ * scaleQuantity({ amount: 1.5, unit: 'cup' }, 2) // { amount: 3, unit: 'cup' }
+ * scaleQuantity({ amount: { min: 2, max: 3 }, unit: 'tbsp' }, 2) // { amount: { min: 4, max: 6 }, unit: 'tbsp' }
+ */
+declare function scaleQuantity<A extends Amount>(quantity: Quantity & {
+    amount: A;
+}, factor: number): {
+    amount: SameAmount<A>;
+    unit?: UnitId | undefined;
+};
+
+/**
+ * Converts a quantity to another unit of the same dimension. Both ends of a
+ * range convert. Nothing is rounded, so the amount can be off in its last
+ * digit: 5 tbsp is 14.999999999999998 tsp.
+ *
+ * @throws {RecipeBookError} `incompatible_units` across dimensions (cup to g),
+ *   between a count unit and a different unit, or for a bare count. Check with
+ *   {@link canConvert} first when the units come from data.
+ * @throws {RecipeBookError} `unknown_unit` when either unit is not a unit id.
+ * @throws {RecipeBookError} `invalid_argument` when `quantity` isn't a quantity object, the amount is not a finite number greater than 0 or a range of them, a range's `min` isn't less than its `max`, the quantity has `max` set, as a `Servings` or `Yield` has, or the result overflows to `Infinity` or underflows to 0, which only an amount above about 1e300 or below about 1e-300 can do.
+ *
+ * @example
+ * convert({ amount: 1, unit: 'cup' }, 'ml') // { amount: 236.5882365, unit: 'ml' }
+ * convert({ amount: { min: 2, max: 3 }, unit: 'tbsp' }, 'tsp') // { amount: { min: 6, max: 9 }, unit: 'tsp' }
+ */
+declare function convert<A extends Amount, To extends UnitId>(quantity: Quantity & {
+    amount: A;
+}, to: To): {
+    amount: SameAmount<A>;
+    unit: To;
+};
+/**
+ * True when {@link convert} can convert between the two units: same unit, or
+ * mass to mass, or volume to volume. Never throws, so it is safe on untrusted data.
+ *
+ * @example
+ * canConvert('cup', 'ml') // true
+ * canConvert('cup', 'g') // false
+ * canConvert(undefined, 'g') // false: a bare count has no size
+ */
+declare function canConvert(from: UnitId | undefined, to: UnitId): boolean;
+/**
+ * Expresses a quantity in a measurement system, choosing the display unit
+ * from that system's ladder: g and kg, ml and l, oz and lb, or tsp, tbsp, and
+ * cup. Nothing is rounded, so the amount can be off in its last digit, as with
+ * {@link convert}.
+ *
+ * Returns the quantity unchanged when its unit is already native to `system`
+ * (tsp and tbsp are native to both), when it is a count unit, or when it has
+ * no unit.
+ *
+ * @throws {RecipeBookError} `invalid_argument` for an unknown system, an invalid amount, a quantity with `max` set, as a `Servings` or `Yield` has, or a result that overflows to `Infinity` or underflows to 0, which only an amount above about 1e300 or below about 1e-300 can do.
+ * @throws {RecipeBookError} `unknown_unit` when the unit is not a unit id.
+ *
+ * @example
+ * toSystem({ amount: 250, unit: 'g' }, 'us') // { amount: 8.818…, unit: 'oz' }
+ * toSystem({ amount: 0.5, unit: 'cup' }, 'metric') // { amount: 118.29…, unit: 'ml' }
+ * toSystem({ amount: 3, unit: 'tsp' }, 'metric') // unchanged
+ */
+declare function toSystem<A extends Amount>(quantity: Quantity & {
+    amount: A;
+}, system: System): {
+    amount: SameAmount<A>;
+    unit?: UnitId | undefined;
+};
+
+/**
+ * Finds the unit that author text names. Surrounding whitespace is ignored,
+ * inner whitespace is collapsed, a period that ends a word is dropped, and
+ * case is ignored except for `'T'` (tbsp), `'t'` (tsp), and `'c'` (cup).
+ *
+ * @returns The unit id, or `undefined` when the text names no known unit.
+ *
+ * @example
+ * findUnit('Tablespoons') // 'tbsp'
+ * findUnit('T') // 'tbsp'
+ * findUnit('fl. oz.') // 'fl-oz'
+ * findUnit('knob') // undefined
+ */
+declare function findUnit<Alias extends UnitAlias>(text: Alias): UnitIdOf<Alias>;
+declare function findUnit<Alias extends UnitAlias>(text: `${Alias}.`): UnitIdOf<Alias>;
+declare function findUnit(text: string): UnitId | undefined;
+/**
+ * Returns the registry entry for a unit id.
+ *
+ * @throws {RecipeBookError} `unknown_unit` when `id` is not a unit id.
+ *
+ * @example
+ * getUnit('cup').toBase // 236.5882365
+ */
+declare function getUnit<Id extends UnitId>(id: Id): UnitDefinition & {
+    readonly id: Id;
+};
+
+/** Degrees Celsius or Fahrenheit. */
+type TemperatureUnit = 'C' | 'F';
+/**
+ * An oven or food temperature. Temperatures are not quantities: converting
+ * them is affine, and scaling a recipe never changes them.
+ */
+type Temperature = {
+    value: number;
+    unit: TemperatureUnit;
+};
+/**
+ * Converts a temperature between Celsius and Fahrenheit. Nothing is rounded,
+ * so the value can be off in its last digits: −18 °C is
+ * −0.3999999999999986 °F.
+ *
+ * @throws {RecipeBookError} `invalid_argument` for a non-finite value, an unknown unit, or a result that overflows to `Infinity` or `-Infinity`, which only a value beyond about ±2e307 can do.
+ *
+ * @example
+ * convertTemperature({ value: 350, unit: 'F' }, 'C') // { value: 176.66…, unit: 'C' }
+ * convertTemperature({ value: 180, unit: 'C' }, 'F') // { value: 356, unit: 'F' }
+ */
+declare function convertTemperature(temperature: Temperature, to: TemperatureUnit): Temperature;
+
+/**
+ * Options every `format*` function takes. Every default is a fixed value,
+ * never read from the runtime, so server and client render the same text.
+ */
+type FormatOptions = {
+    /**
+     * A language tag that `Intl` accepts, such as `'en-US'`, the default. Labels
+     * and plurals are English in 0.1; only numbers follow the locale, and they
+     * are never grouped. Numbers in other languages come from the runtime's
+     * `Intl` data, so the server and client need the same locale support to
+     * render the same text. A locale the runtime doesn't support falls back to
+     * English, but a string `Intl` rejects throws. `Intl` rejects `'en_US'`, and
+     * some BCP 47 tags too, such as `'i-klingon'` and `'x-private'`.
+     */
+    locale?: string | undefined;
+    /** `'short'` (`tbsp`) or `'long'` (`tablespoons`). Default `'short'`. */
+    unitDisplay?: 'short' | 'long' | undefined;
+};
+
+/**
+ * Options for {@link formatQuantity}, {@link formatQuantityToParts},
+ * `formatIngredient`, `formatServings`, and `formatYield`.
+ */
+type FormatQuantityOptions = FormatOptions & {
+    /**
+     * Write US units and counts as fractions, such as `1 ½`. Default `true`.
+     * `false` writes up to two decimals instead (`1.5 cups`, `0.33 cups`), or
+     * more for an amount that would otherwise read as 0. Metric units always
+     * use decimals.
+     */
+    fractions?: boolean | undefined;
+    /**
+     * `'kitchen'` (default) rounds to amounts you can measure: US units to the
+     * nearest ⅛ or ⅓, counts to the nearest ¼, metric units to sensible
+     * decimals. `'none'` writes up to three decimals, or more for an amount
+     * that would otherwise read as 0.
+     */
+    rounding?: 'kitchen' | 'none' | undefined;
+};
+/**
+ * One piece of a formatted quantity, in the style of `Intl` `formatToParts`.
+ * Joining every `value` gives the {@link formatQuantity} text. Unlike `Intl`,
+ * a range's dash is its own `rangeSeparator` part.
+ */
+type QuantityPart = {
+    /** May gain members in a minor release, so give an exhaustive `switch` a default case. */
+    type: 'amount' | 'rangeSeparator' | 'unit' | 'literal';
+    value: string;
+};
+/**
+ * Formats a quantity for display, with kitchen rounding by default.
+ *
+ * - US units (tsp, tbsp, cup, fl oz, pint, quart, gallon, oz, lb) round to the
+ *   nearest ⅛ or ⅓ and counts to the nearest ¼, written as fractions. An
+ *   amount below the smallest step is written as a decimal instead, never as 0.
+ * - g, mL, cL, and dL use one decimal below 10 and none from 10; kg and L up
+ *   to two decimals; mg none. Small amounts gain digits rather than show 0.
+ * - Ranges use an en dash ("2–3 tbsp"), and the amount and unit are joined by a
+ *   no-break space (U+00A0).
+ * - The unit is singular for 1 and for a fraction below 1 ("1 cup", "½ cup"),
+ *   and plural otherwise, including decimals and ranges ("0.5 cups",
+ *   "1 ½ cups", "½–1 cups").
+ *
+ * For `en` alone or with a region, such as `'en-GB'`, output depends only on
+ * the arguments: the locale defaults to `'en-US'`, and those numbers never go
+ * through `Intl`. Other tags, including English ones with extensions such as
+ * `'en-US-u-nu-arab'`, read the runtime's `Intl` data.
+ *
+ * @throws {RecipeBookError} `invalid_argument` for an invalid quantity or option, or a quantity with `max` set, as a `Servings` or `Yield` has (print those with `formatServings` and `formatYield`); `unknown_unit` for an unknown unit id.
+ *
+ * @example
+ * formatQuantity({ amount: 1.5, unit: 'cup' }) // "1 ½ cups"
+ * formatQuantity({ amount: { min: 2, max: 3 }, unit: 'tbsp' }) // "2–3 tbsp"
+ * formatQuantity({ amount: 118.29, unit: 'ml' }) // "118 mL"
+ * formatQuantity({ amount: 0.5, unit: 'tsp' }, { unitDisplay: 'long' }) // "½ teaspoon"
+ */
+declare function formatQuantity(quantity: Quantity, options?: FormatQuantityOptions): string;
+/**
+ * Formats a quantity as parts, so a UI can style the amount and unit
+ * separately without parsing the string.
+ *
+ * @throws {RecipeBookError} The same errors as {@link formatQuantity}, including `invalid_argument` for a quantity with `max` set.
+ *
+ * @example
+ * formatQuantityToParts({ amount: { min: 2, max: 3 }, unit: 'tbsp' })
+ * // [{ type: 'amount', value: '2' }, { type: 'rangeSeparator', value: '–' },
+ * //  { type: 'amount', value: '3' }, { type: 'literal', value: '\u00A0' },
+ * //  { type: 'unit', value: 'tbsp' }]
+ */
+declare function formatQuantityToParts(quantity: Quantity, options?: FormatQuantityOptions): QuantityPart[];
+
+/** An ingredient line as text, in pieces for styling and as one `text` line. */
+type FormattedIngredient = {
+    /** The formatted quantity, as from `formatQuantity`. Absent for an unquantified line. */
+    quantity?: string | undefined;
+    /** The name, or the ingredient's `plural` when a bare count takes the plural: "2 eggs", "1–2 eggs". */
+    name: string;
+    /** The ingredient's note, such as "sifted". Absent when it has none. */
+    note?: string | undefined;
+    /**
+     * The whole line: `'1 ½ cups flour, sifted'`, `'2 eggs'`, `'salt, to taste'`.
+     * It never says "optional"; mark optional ingredients in the UI.
+     */
+    text: string;
+};
+/**
+ * Formats an ingredient line. Accepts a resolved ingredient, or any
+ * `{ ingredient, quantity? }`; without `quantity`, the ingredient's own
+ * quantity is used.
+ *
+ * Takes the same options and rounding as `formatQuantity`. A bare count that
+ * takes the plural, such as `2`, `1–2`, or `0.1`, uses the ingredient's
+ * `plural`, or `name` when it has none. The name follows a no-break space
+ * (U+00A0) after any bare count, `1 egg` included, and a regular space after
+ * a unit.
+ *
+ * @throws {RecipeBookError} `invalid_argument` when `item` is not `{ ingredient, quantity? }` or the ingredient's `plural` or `note` is not a string; otherwise the same errors as `formatQuantity`, including `invalid_argument` for a quantity with `max` set.
+ *
+ * @example
+ * formatIngredient(resolved).text // "250 g all-purpose flour"
+ * formatIngredient({ ingredient: eggs, quantity: { amount: 2 } }).text // "2 eggs"
+ * formatIngredient({ ingredient: salt }) // { name: 'salt', note: 'to taste', text: 'salt, to taste' }
+ */
+declare function formatIngredient(item: {
+    ingredient: Ingredient;
+    quantity?: Quantity | undefined;
+}, options?: FormatQuantityOptions): FormattedIngredient;
+
+/**
+ * Formats a number of servings as only the number or range: "4", "4–6",
+ * "2 ½". The UI adds the word, as in "Serves 4–6" or "4–6 servings".
+ *
+ * Numbers format as `formatQuantity` formats a bare count. It takes
+ * `formatQuantity`'s options; `unitDisplay` has no effect.
+ *
+ * Scale with `resolveRecipe`, and print with `formatServings` and `formatYield`, not `formatQuantity`.
+ *
+ * @throws {RecipeBookError} `invalid_argument` for a value that isn't `{ amount, max? }` with `max` above `amount`, or for an invalid option.
+ *
+ * @example
+ * formatServings({ amount: 4 }) // "4"
+ * formatServings({ amount: 4, max: 6 }) // "4–6"
+ * formatServings({ amount: 2.5 }) // "2 ½": 5 servings at scale 0.5
+ */
+declare function formatServings(servings: Servings, options?: FormatQuantityOptions): string;
+/**
+ * Formats what a batch makes: the number or range, a no-break space
+ * (U+00A0), then the yield's word, as in "24 cookies", "2–3 loaves", or
+ * "1 loaf".
+ *
+ * Numbers format as `formatQuantity` formats a bare count. The word is `unit`
+ * for 1 and for a fraction below 1 ("1 loaf", "½ loaf"), and `plural`
+ * otherwise, including decimals and ranges ("1 ½ loaves", "1–2 loaves"). A
+ * yield read from text, such as `'2 loaves'`, has no `plural`, so its unit
+ * prints as written. The word is the author's and is never translated. It
+ * takes `formatQuantity`'s options; `unitDisplay` has no effect.
+ *
+ * Scale with `resolveRecipe`, and print with `formatServings` and `formatYield`, not `formatQuantity`.
+ *
+ * @throws {RecipeBookError} `invalid_argument` for a value that isn't `{ amount, max?, unit, plural? }` with `max` above `amount` and string words, or for an invalid option.
+ *
+ * @example
+ * formatYield({ amount: 24, unit: 'cookie', plural: 'cookies' }) // "24 cookies"
+ * formatYield({ amount: 1, unit: 'loaf', plural: 'loaves' }) // "1 loaf"
+ * formatYield({ amount: 2, max: 3, unit: 'loaf', plural: 'loaves' }) // "2–3 loaves"
+ * formatYield({ amount: 1.5, unit: 'loaf', plural: 'loaves' }) // "1 ½ loaves": 3 loaves at scale 0.5
+ * formatYield({ amount: 2, unit: 'loaves' }) // "2 loaves"
+ */
+declare function formatYield(yield_: Yield, options?: FormatQuantityOptions): string;
+
+/** Options for {@link formatTemperature}. */
+type FormatTemperatureOptions = FormatOptions & {
+    /**
+     * `'kitchen'` (default) writes whole degrees. `'oven'` rounds to the nearest
+     * 10 °C or 25 °F. `'none'` writes up to three decimals.
+     */
+    rounding?: 'kitchen' | 'oven' | 'none' | undefined;
+};
+/**
+ * Formats a temperature, such as "180 °C" or "350 degrees Fahrenheit". The
+ * number and unit are joined by a no-break space (U+00A0).
+ *
+ * Rounding is `'kitchen'` by default: whole degrees. `'oven'` rounds to the
+ * steps oven dials and recipes use, the nearest 10 °C or 25 °F, so a converted
+ * 176.67 °C reads "180 °C" and 356 °F reads "350 °F". `'none'` writes up to
+ * three decimals.
+ *
+ * @throws {RecipeBookError} `invalid_argument` for an invalid temperature or option.
+ *
+ * @example
+ * formatTemperature({ value: 176.66, unit: 'C' }, { rounding: 'oven' }) // "180 °C"
+ * formatTemperature(convertTemperature({ value: 180, unit: 'C' }, 'F'), { rounding: 'oven' }) // "350 °F"
+ * formatTemperature({ value: 350, unit: 'F' }, { unitDisplay: 'long' }) // "350 degrees Fahrenheit"
+ */
+declare function formatTemperature(temperature: Temperature, options?: FormatTemperatureOptions): string;
+
+/**
+ * Formats a duration in minutes, such as a recipe's `times.cook`: "45 min",
+ * "1 hr 15 min", or with `unitDisplay: 'long'`, "1 hour 15 minutes".
+ *
+ * The duration is rounded to the second and written in days, hours, minutes,
+ * and seconds, leaving out zero parts. Each number and unit is joined by a
+ * no-break space (U+00A0).
+ *
+ * @throws {RecipeBookError} `invalid_argument` when `minutes` is not a finite number, 0 or more, or for an invalid option.
+ *
+ * @example
+ * formatDuration(75) // "1 hr 15 min"
+ * formatDuration(1.5) // "1 min 30 sec"
+ * formatDuration(2880, { unitDisplay: 'long' }) // "2 days"
+ * formatDuration(0) // "0 min"
+ */
+declare function formatDuration(minutes: number, options?: FormatOptions): string;
+
+/** A temperature read from step text, and whether it is for a fan oven. */
+type TemperatureReading = {
+    temperature: Temperature;
+    /**
+     * True when the text marks it for a fan or convection oven, as in "170C
+     * fan". A marker after a segment's closing parenthesis, as in "170°C (about
+     * 340°F) fan", marks every reading in the segment. An unmarked reading in
+     * parentheses that restates a marked one, in the other unit and within 10 °C,
+     * is marked too, as in "170°C fan (about 340°F)". In "160°C fan (350°F)",
+     * 350 °F is 177 °C, so it isn't. Otherwise, a marker with other words between
+     * it and the reading, as in "325°F for convection", isn't read.
+     */
+    fan: boolean;
+};
+/** Step text with nothing recognized in it. */
+type TextSegment = {
+    type: 'text';
+    text: string;
+};
+/**
+ * A temperature in step text. When the author already wrote the setting more
+ * than one way, as in "400 degrees F (200 degrees C)" or "190C/170C fan/gas 5",
+ * the whole run is one segment: the first reading is `temperature`, the others
+ * are `alternatives`, and `text` keeps any gas mark uninterpreted. Readings
+ * with the same `fan` value are one setting in both units, within 10 °C of
+ * each other, so no two share a unit and a `fan` value.
+ */
+type TemperatureSegment = TemperatureReading & {
+    type: 'temperature';
+    /** The text exactly as authored, such as `'350°F'` or `'200C/180C fan forced'`. */
+    text: string;
+    /** The other readings in this segment, in authored order. Often empty. */
+    alternatives: TemperatureReading[];
+};
+/**
+ * A piece of step text. Recognizes temperatures in 0.1; durations and other
+ * kinds may be added in minor releases, so handle unknown `type`s as text.
+ */
+type StepSegment = TextSegment | TemperatureSegment;
+/** Options for {@link segmentStepText}. */
+type SegmentStepTextOptions = {
+    /**
+     * Scale for a temperature written with a degree sign or the word "degree" or
+     * "degrees" but no scale, such as "Bake at 350 degrees", "Bake in a
+     * 350-degree oven." or "Preheat oven to 350°." Default: none, so those stay
+     * text. A number with no degree sign or word, as in "Preheat oven to 350.",
+     * stays text even with a scale. With one, such a temperature counts only
+     * after a word such as "at" or "to", before "oven", or when a reading in the
+     * other unit restates it, as in "350° (175°C)", so "rotate the pan 180
+     * degrees" stays text.
+     */
+    assumeTemperatureUnit?: TemperatureUnit | undefined;
+};
+/**
+ * Splits step text into plain text and the temperatures in it. Joining every
+ * segment's `text` gives back the input exactly.
+ *
+ * @throws {RecipeBookError} `invalid_argument` for text that isn't a string or an unknown `assumeTemperatureUnit`.
+ *
+ * @example
+ * segmentStepText('Bake at 350°F for 20 minutes.')
+ * // [
+ * //   { type: 'text', text: 'Bake at ' },
+ * //   { type: 'temperature', text: '350°F', temperature: { value: 350, unit: 'F' }, fan: false, alternatives: [] },
+ * //   { type: 'text', text: ' for 20 minutes.' },
+ * // ]
+ */
+declare function segmentStepText(text: string, options?: SegmentStepTextOptions): StepSegment[];
+
+export { Amount, Ingredient, ParseResult, Quantity, Range, Recipe, Servings, StandardSchemaV1, StandardTypedV1, Step, System, UnitAlias, UnitDefinition, UnitId, UnitIdOf, Yield, canConvert, convert, convertTemperature, createRecipeSchema, findUnit, formatDuration, formatIngredient, formatQuantity, formatQuantityToParts, formatServings, formatTemperature, formatYield, getUnit, parseIngredientLine, parseQuantity, parseRecipe, recipeSchema, resolveIngredient, resolveRecipe, scaleQuantity, segmentStepText, toSystem };
+export type { CustomTimeInput, DurationInput, EquipmentInput, FormatOptions, FormatQuantityOptions, FormatTemperatureOptions, FormattedIngredient, IngredientInput, IngredientLine, IngredientSectionInput, NoteInput, NutrientInput, NutritionInput, ParseRecipeOptions, QuantityInput, QuantityOrigin, QuantityPart, QuantityString, RecipeInput, RecipeSchema, ResolveIngredientOptions, ResolveRecipeOptions, ResolvedIngredient, ResolvedRecipe, SegmentStepTextOptions, ServingsInput, StepInput, StepSectionInput, StepSegment, Temperature, TemperatureReading, TemperatureSegment, TemperatureUnit, TextSegment, TimesInput, YieldInput };