@elaraai/e3-ui 1.0.94 → 1.0.95

package/dist/src/allocation/functions.d.ts

@@ -0,0 +1,664 @@
+/**
+ * Copyright (c) 2025 Elara AI Pty Ltd
+ * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
+ */
+/**
+ * The Allocation's pure functions (`Allocation Spec.md` §5.1, §12): a day's
+ * loads, a fit's candidates, the built-in rules, an answer to a fit's
+ * question, a greedy look-ahead, the built-in checks and the day's slots, and
+ * a bin as the board reads it from the app's row. Tasks, the app's
+ * `e3.function` fit and the renderer run these same East functions, so the
+ * screen and e3 agree on every figure and every word.
+ *
+ * Those over a day take the app's bin row type (#1371, `Builder Interfaces
+ * Spec.md` §6.3), as `Editing.apply` takes its source type:
+ * `Allocation.loads(KilnBin)` is an East function over
+ * `Allocation.Types.Day(KilnBin)`. They read each bin's roles, never its row,
+ * which they carry for the app's own functions. `Allocation.fit` reads one
+ * candidate, so it needs none.
+ *
+ * @packageDocumentation
+ */
+import { ArrayType, BooleanType, DateTimeType, DictType, FloatType, FunctionType, IntegerType, OptionType, StringType, StructType, type EastType, type ExprType } from "@elaraai/east";
+import { ScheduleAllocationRolesType } from "../schedule/types.js";
+import { AllocationCandidateType, AllocationFitResultType, AllocationFitType, AllocationIssueType, AllocationLoadType, AllocationSlotType, type AllocationBinType, type AllocationContextType as ContextType, type AllocationDayType, type AllocationFitRequestType } from "./types.js";
+/**
+ * A duration in milliseconds — a month counts 30 days, as Schedule's do.
+ *
+ * @param step - The duration
+ * @returns Its length in milliseconds
+ */
+export declare const allocationMilliseconds: import("@elaraai/east").CallableFunctionExpr<[import("@elaraai/east").VariantType<{
+    readonly minutes: FloatType;
+    readonly hours: FloatType;
+    readonly days: FloatType;
+    readonly weeks: FloatType;
+    readonly months: FloatType;
+}>], IntegerType>;
+/**
+ * A quantity and its unit.
+ *
+ * @param value - The quantity
+ * @param unit - The unit, or empty
+ * @returns `21 m³`, or `21` with no unit
+ */
+export declare const allocationQuantityText: import("@elaraai/east").CallableFunctionExpr<[FloatType, StringType], StringType>;
+/**
+ * A day as the board names it.
+ *
+ * @param at - An instant on the day
+ * @returns `Wed 19`
+ */
+export declare const allocationDayText: import("@elaraai/east").CallableFunctionExpr<[DateTimeType], StringType>;
+/**
+ * A resource's load, naming the limit it breaks (A19).
+ *
+ * @param fill - What its bins put on it
+ * @param resource - The resource
+ * @param unit - The quantity's unit
+ * @returns `11 m³ · max 9 · 2 over`, `16 m³ · min 40 · 24 short`, or `45 m³ · takes 26–48`
+ */
+export declare const allocationLoadText: import("@elaraai/east").CallableFunctionExpr<[FloatType, StructType<{
+    readonly key: StringType;
+    readonly label: StringType;
+    readonly group: OptionType<StringType>;
+    readonly meta: OptionType<StringType>;
+    readonly note: OptionType<StringType>;
+    readonly min: FloatType;
+    readonly max: FloatType;
+    readonly hold: import("@elaraai/east").VariantType<{
+        readonly minutes: FloatType;
+        readonly hours: FloatType;
+        readonly days: FloatType;
+        readonly weeks: FloatType;
+        readonly months: FloatType;
+    }>;
+    readonly jobs: ArrayType<StructType<{
+        readonly label: StringType;
+        readonly start: DateTimeType;
+        readonly end: DateTimeType;
+    }>>;
+}>, StringType], StringType>;
+/**
+ * The job that makes a resource busy on a day: one covering the day's start,
+ * the latest to end of them.
+ *
+ * @param resource - The resource
+ * @param day - The plan day
+ * @returns The job, or `none`
+ */
+export declare const allocationBusyJob: import("@elaraai/east").CallableFunctionExpr<[StructType<{
+    readonly key: StringType;
+    readonly label: StringType;
+    readonly group: OptionType<StringType>;
+    readonly meta: OptionType<StringType>;
+    readonly note: OptionType<StringType>;
+    readonly min: FloatType;
+    readonly max: FloatType;
+    readonly hold: import("@elaraai/east").VariantType<{
+        readonly minutes: FloatType;
+        readonly hours: FloatType;
+        readonly days: FloatType;
+        readonly weeks: FloatType;
+        readonly months: FloatType;
+    }>;
+    readonly jobs: ArrayType<StructType<{
+        readonly label: StringType;
+        readonly start: DateTimeType;
+        readonly end: DateTimeType;
+    }>>;
+}>, DateTimeType], OptionType<StructType<{
+    readonly label: StringType;
+    readonly start: DateTimeType;
+    readonly end: DateTimeType;
+}>>>;
+/**
+ * A resource's next job after a day's start: the first to start.
+ *
+ * @param resource - The resource
+ * @param day - The plan day
+ * @returns The job, or `none`
+ */
+export declare const allocationNextJob: import("@elaraai/east").CallableFunctionExpr<[StructType<{
+    readonly key: StringType;
+    readonly label: StringType;
+    readonly group: OptionType<StringType>;
+    readonly meta: OptionType<StringType>;
+    readonly note: OptionType<StringType>;
+    readonly min: FloatType;
+    readonly max: FloatType;
+    readonly hold: import("@elaraai/east").VariantType<{
+        readonly minutes: FloatType;
+        readonly hours: FloatType;
+        readonly days: FloatType;
+        readonly weeks: FloatType;
+        readonly months: FloatType;
+    }>;
+    readonly jobs: ArrayType<StructType<{
+        readonly label: StringType;
+        readonly start: DateTimeType;
+        readonly end: DateTimeType;
+    }>>;
+}>, DateTimeType], OptionType<StructType<{
+    readonly label: StringType;
+    readonly start: DateTimeType;
+    readonly end: DateTimeType;
+}>>>;
+/**
+ * A resource's line on the plan day (A19), and the marks its bins' cards carry
+ * (A16).
+ *
+ * @param day - The plan day
+ * @param resource - The resource
+ * @param load - Its load
+ * @param unit - The quantity's unit
+ * @returns Its line, its tone, whether it is over its maximum, under its minimum, or held into its next job, and that job
+ *
+ * @remarks
+ * Loading, the line is its load (`45 m³ · takes 26–48`; `reserved · takes
+ * 26–48` with only reservations) and `· 2 d into next job` when its hold runs
+ * into the job; busy, `busy until Fri 14`; free, its meta (or its group) and
+ * what it takes (`Hall B · 40 m³ · takes 20–40 m³`).
+ */
+export declare const allocationResourceLine: import("@elaraai/east").CallableFunctionExpr<[DateTimeType, StructType<{
+    readonly key: StringType;
+    readonly label: StringType;
+    readonly group: OptionType<StringType>;
+    readonly meta: OptionType<StringType>;
+    readonly note: OptionType<StringType>;
+    readonly min: FloatType;
+    readonly max: FloatType;
+    readonly hold: import("@elaraai/east").VariantType<{
+        readonly minutes: FloatType;
+        readonly hours: FloatType;
+        readonly days: FloatType;
+        readonly weeks: FloatType;
+        readonly months: FloatType;
+    }>;
+    readonly jobs: ArrayType<StructType<{
+        readonly label: StringType;
+        readonly start: DateTimeType;
+        readonly end: DateTimeType;
+    }>>;
+}>, StructType<{
+    readonly resource: StringType;
+    readonly fill: FloatType;
+    readonly bins: IntegerType;
+    readonly hold: OptionType<StructType<{
+        readonly from: DateTimeType;
+        readonly to: DateTimeType;
+    }>>;
+    readonly state: import("@elaraai/east").VariantType<{
+        readonly free: import("@elaraai/east").NullType;
+        readonly loading: import("@elaraai/east").NullType;
+        readonly busy: import("@elaraai/east").NullType;
+    }>;
+}>, StringType], StructType<{
+    readonly text: StringType;
+    readonly tone: import("@elaraai/east").VariantType<{
+        readonly success: import("@elaraai/east").NullType;
+        readonly warning: import("@elaraai/east").NullType;
+        readonly danger: import("@elaraai/east").NullType;
+        readonly info: import("@elaraai/east").NullType;
+        readonly neutral: import("@elaraai/east").NullType;
+    }>;
+    readonly over: BooleanType;
+    readonly under: BooleanType;
+    readonly overlap: BooleanType;
+    readonly next: OptionType<StructType<{
+        readonly label: StringType;
+        readonly start: DateTimeType;
+        readonly end: DateTimeType;
+    }>>;
+}>>;
+/**
+ * One bin, as the board reads it on its plan day (#1371, B12): its kind's
+ * roles beside its row — a stored bin's roles as the kind's `rows` gives them,
+ * a drafted one's as its `read` does.
+ *
+ * @typeParam R - The app's bin row type
+ * @param row - The app's bin row type
+ * @returns An East function `(roles, row, day) → Option<Bin(R)>`: the bin, when its `at` falls in the day `[day, day + 1 d)`; `none` for a bin of another day
+ *
+ * @remarks
+ * A bin's UTC day is its plan day (`Builder Interfaces Spec.md` §6.2), so the
+ * board's day holds the bins whose `at` falls in it, `day` its UTC midnight.
+ * Each bin's `at` is read as it is, so a batch's bins, booked a minute apart,
+ * read back a minute apart, in one slot (`Allocation.slots`).
+ * @internal
+ */
+export declare function allocationBinOf<R extends EastType>(row: R): ExprType<FunctionType<[ScheduleAllocationRolesType, R, DateTimeType], OptionType<AllocationBinType<R>>>>;
+/**
+ * One bin's part on one resource, as loads and candidates read it.
+ *
+ * @property bin - The bin's id; empty for a placement the look-ahead adds
+ * @property quantity - Its part's quantity
+ * @property hold - Its hold, in milliseconds
+ * @property kind - Its kind
+ * @property reserve - Whether it is a reservation
+ * @internal
+ */
+export declare const AllocationMateType: StructType<{
+    readonly bin: StringType;
+    readonly quantity: FloatType;
+    readonly hold: IntegerType;
+    readonly kind: OptionType<StringType>;
+    readonly reserve: BooleanType;
+}>;
+/** The bins' parts on every resource, by the resource's key. @internal */
+declare const MatesType: DictType<StringType, ArrayType<StructType<{
+    readonly bin: StringType;
+    readonly quantity: FloatType;
+    readonly hold: IntegerType;
+    readonly kind: OptionType<StringType>;
+    readonly reserve: BooleanType;
+}>>>;
+/**
+ * Every resource's parts of the day's bins, an entry for every resource.
+ *
+ * @typeParam R - The app's bin row type
+ * @param row - The app's bin row type
+ * @returns An East function from the day and the context to the parts on each resource
+ * @internal
+ */
+export declare function allocationMates<R extends EastType>(row: R): ExprType<FunctionType<[AllocationDayType<R>, ContextType], typeof MatesType>>;
+/**
+ * A resource's load from its parts.
+ *
+ * @param day - The plan day
+ * @param resource - The resource
+ * @param mates - Its parts
+ * @returns Its load
+ * @internal
+ */
+export declare const allocationLoadOf: import("@elaraai/east").CallableFunctionExpr<[DateTimeType, StructType<{
+    readonly key: StringType;
+    readonly label: StringType;
+    readonly group: OptionType<StringType>;
+    readonly meta: OptionType<StringType>;
+    readonly note: OptionType<StringType>;
+    readonly min: FloatType;
+    readonly max: FloatType;
+    readonly hold: import("@elaraai/east").VariantType<{
+        readonly minutes: FloatType;
+        readonly hours: FloatType;
+        readonly days: FloatType;
+        readonly weeks: FloatType;
+        readonly months: FloatType;
+    }>;
+    readonly jobs: ArrayType<StructType<{
+        readonly label: StringType;
+        readonly start: DateTimeType;
+        readonly end: DateTimeType;
+    }>>;
+}>, ArrayType<StructType<{
+    readonly bin: StringType;
+    readonly quantity: FloatType;
+    readonly hold: IntegerType;
+    readonly kind: OptionType<StringType>;
+    readonly reserve: BooleanType;
+}>>], StructType<{
+    readonly resource: StringType;
+    readonly fill: FloatType;
+    readonly bins: IntegerType;
+    readonly hold: OptionType<StructType<{
+        readonly from: DateTimeType;
+        readonly to: DateTimeType;
+    }>>;
+    readonly state: import("@elaraai/east").VariantType<{
+        readonly free: import("@elaraai/east").NullType;
+        readonly loading: import("@elaraai/east").NullType;
+        readonly busy: import("@elaraai/east").NullType;
+    }>;
+}>>;
+/**
+ * One candidate: a quantity on a resource, against the parts it already holds.
+ *
+ * @param day - The plan day
+ * @param bin - The bin it is for, if any
+ * @param reserve - Whether it reserves a slot
+ * @param quantity - What the resource would hold of it
+ * @param arrival - Its arrival, if any
+ * @param kind - Its kind
+ * @param hold - Its hold, in milliseconds
+ * @param resource - The resource
+ * @param mates - The resource's other parts
+ * @param load - The resource's load
+ * @param rules - The built-in rules
+ * @param unit - The quantity's unit
+ * @returns The candidate
+ * @internal
+ */
+export declare const allocationCandidateOf: import("@elaraai/east").CallableFunctionExpr<[DateTimeType, OptionType<StringType>, BooleanType, FloatType, OptionType<StructType<{
+    readonly key: StringType;
+    readonly label: StringType;
+    readonly meta: OptionType<StringType>;
+    readonly quantity: FloatType;
+    readonly hold: import("@elaraai/east").VariantType<{
+        readonly minutes: FloatType;
+        readonly hours: FloatType;
+        readonly days: FloatType;
+        readonly weeks: FloatType;
+        readonly months: FloatType;
+    }>;
+    readonly kind: OptionType<StringType>;
+    readonly due: OptionType<DateTimeType>;
+    readonly window: OptionType<StructType<{
+        readonly from: DateTimeType;
+        readonly to: DateTimeType;
+    }>>;
+    readonly details: ArrayType<StructType<{
+        readonly label: StringType;
+        readonly value: StringType;
+    }>>;
+}>>, OptionType<StringType>, IntegerType, StructType<{
+    readonly key: StringType;
+    readonly label: StringType;
+    readonly group: OptionType<StringType>;
+    readonly meta: OptionType<StringType>;
+    readonly note: OptionType<StringType>;
+    readonly min: FloatType;
+    readonly max: FloatType;
+    readonly hold: import("@elaraai/east").VariantType<{
+        readonly minutes: FloatType;
+        readonly hours: FloatType;
+        readonly days: FloatType;
+        readonly weeks: FloatType;
+        readonly months: FloatType;
+    }>;
+    readonly jobs: ArrayType<StructType<{
+        readonly label: StringType;
+        readonly start: DateTimeType;
+        readonly end: DateTimeType;
+    }>>;
+}>, ArrayType<StructType<{
+    readonly bin: StringType;
+    readonly quantity: FloatType;
+    readonly hold: IntegerType;
+    readonly kind: OptionType<StringType>;
+    readonly reserve: BooleanType;
+}>>, StructType<{
+    readonly resource: StringType;
+    readonly fill: FloatType;
+    readonly bins: IntegerType;
+    readonly hold: OptionType<StructType<{
+        readonly from: DateTimeType;
+        readonly to: DateTimeType;
+    }>>;
+    readonly state: import("@elaraai/east").VariantType<{
+        readonly free: import("@elaraai/east").NullType;
+        readonly loading: import("@elaraai/east").NullType;
+        readonly busy: import("@elaraai/east").NullType;
+    }>;
+}>, StructType<{
+    readonly under: BooleanType;
+}>, StringType], StructType<{
+    readonly day: DateTimeType;
+    readonly bin: OptionType<StringType>;
+    readonly reserve: BooleanType;
+    readonly quantity: FloatType;
+    readonly arrival: OptionType<StructType<{
+        readonly key: StringType;
+        readonly label: StringType;
+        readonly meta: OptionType<StringType>;
+        readonly quantity: FloatType;
+        readonly hold: import("@elaraai/east").VariantType<{
+            readonly minutes: FloatType;
+            readonly hours: FloatType;
+            readonly days: FloatType;
+            readonly weeks: FloatType;
+            readonly months: FloatType;
+        }>;
+        readonly kind: OptionType<StringType>;
+        readonly due: OptionType<DateTimeType>;
+        readonly window: OptionType<StructType<{
+            readonly from: DateTimeType;
+            readonly to: DateTimeType;
+        }>>;
+        readonly details: ArrayType<StructType<{
+            readonly label: StringType;
+            readonly value: StringType;
+        }>>;
+    }>>;
+    readonly kind: OptionType<StringType>;
+    readonly resource: StructType<{
+        readonly key: StringType;
+        readonly label: StringType;
+        readonly group: OptionType<StringType>;
+        readonly meta: OptionType<StringType>;
+        readonly note: OptionType<StringType>;
+        readonly min: FloatType;
+        readonly max: FloatType;
+        readonly hold: import("@elaraai/east").VariantType<{
+            readonly minutes: FloatType;
+            readonly hours: FloatType;
+            readonly days: FloatType;
+            readonly weeks: FloatType;
+            readonly months: FloatType;
+        }>;
+        readonly jobs: ArrayType<StructType<{
+            readonly label: StringType;
+            readonly start: DateTimeType;
+            readonly end: DateTimeType;
+        }>>;
+    }>;
+    readonly load: StructType<{
+        readonly resource: StringType;
+        readonly fill: FloatType;
+        readonly bins: IntegerType;
+        readonly hold: OptionType<StructType<{
+            readonly from: DateTimeType;
+            readonly to: DateTimeType;
+        }>>;
+        readonly state: import("@elaraai/east").VariantType<{
+            readonly free: import("@elaraai/east").NullType;
+            readonly loading: import("@elaraai/east").NullType;
+            readonly busy: import("@elaraai/east").NullType;
+        }>;
+    }>;
+    readonly after: FloatType;
+    readonly hold: StructType<{
+        readonly from: DateTimeType;
+        readonly to: DateTimeType;
+    }>;
+    readonly spare: OptionType<FloatType>;
+    readonly kindMates: BooleanType;
+    readonly otherMates: BooleanType;
+    readonly rules: StructType<{
+        readonly under: BooleanType;
+    }>;
+    readonly unit: StringType;
+}>>;
+/**
+ * The built-in rules (§12.3): one verdict for one candidate.
+ *
+ * @param candidate - A quantity on a resource, against the drafted day
+ * @returns Its verdict
+ *
+ * @remarks
+ * In order: a job covering the day's start refuses it (`busy until Fri 14`);
+ * a hold running past the next job's start refuses it (`gap too short · next
+ * job Wed 19`); a fill over the maximum refuses it (`over max by 4 m³`); a
+ * reservation on a resource already at its maximum is refused (`full · …`).
+ * Otherwise it fits: its score is what it fills of the maximum, plus 0.25 when
+ * a bin of its kind is already there, less 0.1 when only other kinds are, less
+ * 0.5 under the minimum, less 0.04 a spare day up to six; its reason the spare
+ * days and the load it leaves; under the minimum it warns, when the rules ask.
+ */
+export declare const allocationFit: import("@elaraai/east").CallableFunctionExpr<[StructType<{
+    readonly day: DateTimeType;
+    readonly bin: OptionType<StringType>;
+    readonly reserve: BooleanType;
+    readonly quantity: FloatType;
+    readonly arrival: OptionType<StructType<{
+        readonly key: StringType;
+        readonly label: StringType;
+        readonly meta: OptionType<StringType>;
+        readonly quantity: FloatType;
+        readonly hold: import("@elaraai/east").VariantType<{
+            readonly minutes: FloatType;
+            readonly hours: FloatType;
+            readonly days: FloatType;
+            readonly weeks: FloatType;
+            readonly months: FloatType;
+        }>;
+        readonly kind: OptionType<StringType>;
+        readonly due: OptionType<DateTimeType>;
+        readonly window: OptionType<StructType<{
+            readonly from: DateTimeType;
+            readonly to: DateTimeType;
+        }>>;
+        readonly details: ArrayType<StructType<{
+            readonly label: StringType;
+            readonly value: StringType;
+        }>>;
+    }>>;
+    readonly kind: OptionType<StringType>;
+    readonly resource: StructType<{
+        readonly key: StringType;
+        readonly label: StringType;
+        readonly group: OptionType<StringType>;
+        readonly meta: OptionType<StringType>;
+        readonly note: OptionType<StringType>;
+        readonly min: FloatType;
+        readonly max: FloatType;
+        readonly hold: import("@elaraai/east").VariantType<{
+            readonly minutes: FloatType;
+            readonly hours: FloatType;
+            readonly days: FloatType;
+            readonly weeks: FloatType;
+            readonly months: FloatType;
+        }>;
+        readonly jobs: ArrayType<StructType<{
+            readonly label: StringType;
+            readonly start: DateTimeType;
+            readonly end: DateTimeType;
+        }>>;
+    }>;
+    readonly load: StructType<{
+        readonly resource: StringType;
+        readonly fill: FloatType;
+        readonly bins: IntegerType;
+        readonly hold: OptionType<StructType<{
+            readonly from: DateTimeType;
+            readonly to: DateTimeType;
+        }>>;
+        readonly state: import("@elaraai/east").VariantType<{
+            readonly free: import("@elaraai/east").NullType;
+            readonly loading: import("@elaraai/east").NullType;
+            readonly busy: import("@elaraai/east").NullType;
+        }>;
+    }>;
+    readonly after: FloatType;
+    readonly hold: StructType<{
+        readonly from: DateTimeType;
+        readonly to: DateTimeType;
+    }>;
+    readonly spare: OptionType<FloatType>;
+    readonly kindMates: BooleanType;
+    readonly otherMates: BooleanType;
+    readonly rules: StructType<{
+        readonly under: BooleanType;
+    }>;
+    readonly unit: StringType;
+}>], import("@elaraai/east").VariantType<{
+    readonly fits: StructType<{
+        readonly score: FloatType;
+        readonly why: StringType;
+        readonly warn: OptionType<StringType>;
+    }>;
+    readonly refused: StructType<{
+        readonly group: StringType;
+        readonly reason: StringType;
+        readonly measure: import("@elaraai/east").VariantType<{
+            readonly none: import("@elaraai/east").NullType;
+            readonly amount: StructType<{
+                readonly lead: StringType;
+                readonly value: FloatType;
+            }>;
+            readonly day: StructType<{
+                readonly lead: StringType;
+                readonly at: DateTimeType;
+            }>;
+        }>;
+    }>;
+}>>;
+/**
+ * Every resource's load on the plan day.
+ *
+ * @typeParam R - The app's bin row type
+ * @param row - The app's bin row type
+ * @returns An East function `(day, plan, context) → Dict<String, Load>`: an entry for every resource, by key
+ */
+export declare function allocationLoads<R extends EastType>(row: R): ExprType<FunctionType<[DateTimeType, AllocationDayType<R>, ContextType], DictType<StringType, typeof AllocationLoadType>>>;
+/**
+ * The candidates for a fit's question.
+ *
+ * @typeParam R - The app's bin row type
+ * @param row - The app's bin row type
+ * @returns An East function `(request) → Array<Candidate>`: a place's subject on every resource, in the resources' key order; or for a take, every bin on its resource, then every arrival the day has not booked, then a reservation
+ *
+ * @remarks
+ * A bin is placed with its own kind and hold, an arrival with its, and a bin
+ * booking no arrival — a reservation — with no quantity and each resource's
+ * own hold (§12.3, rule 4); the resource's other parts are every bin's but
+ * the subject's. A take places each bin's unallocated quantity (with its part
+ * already there), or the whole bin when it has none; then each arrival no bin
+ * of the day books, whole, as a place of it would; and last a reservation with
+ * the resource's hold.
+ */
+export declare function allocationCandidates<R extends EastType>(row: R): ExprType<FunctionType<[AllocationFitRequestType<R>], ArrayType<typeof AllocationCandidateType>>>;
+/**
+ * Answers a fit's question with a fit per candidate.
+ *
+ * @typeParam R - The app's bin row type
+ * @param row - The app's bin row type
+ * @returns An East function `(request, fit, basis) → FitResult`: a place's verdict for every resource, or a take's for every bin, every arrival the day has not booked, and reserving; `basis` says in words how the fit ranks (`ranked by load, kind and spare days`)
+ */
+export declare function allocationAnswer<R extends EastType>(row: R): ExprType<FunctionType<[AllocationFitRequestType<R>, FunctionType<[typeof AllocationCandidateType], typeof AllocationFitType>, StringType], typeof AllocationFitResultType>>;
+/**
+ * A greedy look-ahead over a fit (§12.4): what a placement leaves for the
+ * day's other arrivals.
+ *
+ * @typeParam R - The app's bin row type
+ * @param row - The app's bin row type
+ * @returns An East function `(request, candidate, fit) → Fit`
+ *
+ * @remarks
+ * A refusal is returned as `fit` gives it. A fit places the candidate — a bin
+ * moves whole onto the candidate's resource with the candidate's quantity —
+ * then each of the day's unbooked arrivals, largest first (ties in key
+ * order), on the resource `fit` scores best for it (ties in key order), and
+ * lowers the score by one for each arrival left with nowhere to go, adding
+ * `· leaves 1 load with no fit` to its reason.
+ */
+export declare function allocationLookahead<R extends EastType>(row: R): ExprType<FunctionType<[AllocationFitRequestType<R>, typeof AllocationCandidateType, FunctionType<[typeof AllocationCandidateType], typeof AllocationFitType>], typeof AllocationFitType>>;
+/**
+ * The built-in checks (§12.3), over committed and drafted bins alike.
+ *
+ * @typeParam R - The app's bin row type
+ * @param row - The app's bin row type
+ * @returns An East function `(day, plan, context) → Array<Issue>`: bins not linked, then partly allocated, then resources whose hold overlaps their next job, over their maximum, and under their minimum when the rules ask
+ *
+ * @remarks
+ * Issues never block Save or Publish. A resource's issue offers to move its
+ * latest bin; the app's `check` follows these wherever issues show.
+ */
+export declare function allocationCheck<R extends EastType>(row: R): ExprType<FunctionType<[DateTimeType, AllocationDayType<R>, ContextType], ArrayType<typeof AllocationIssueType>>>;
+/**
+ * The plan day's lane slots: one per lane per `every`, in time then lane order.
+ *
+ * @typeParam R - The app's bin row type
+ * @param row - The app's bin row type
+ * @returns An East function `(day, plan, context) → Array<Slot>`
+ *
+ * @remarks
+ * A bin is in the slot whose time it follows: from ten minutes before the
+ * slot's time to ten minutes before the next one's, as a batch follows its
+ * slot by a minute a bin. A slot holding a bin booking an arrival is booked,
+ * one holding only reservations reserved, an empty one free. A bin in a lane
+ * the context does not have is in no slot.
+ */
+export declare function allocationSlots<R extends EastType>(row: R): ExprType<FunctionType<[DateTimeType, AllocationDayType<R>, ContextType], ArrayType<typeof AllocationSlotType>>>;
+export {};
+//# sourceMappingURL=functions.d.ts.map

package/dist/src/allocation/functions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"functions.d.ts","sourceRoot":"","sources":["../../../src/allocation/functions.ts"],"names":[],"mappings":"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"}