@elaraai/e3-ui 1.0.94 → 1.0.95

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

@@ -0,0 +1,832 @@
+/**
+ * Copyright (c) 2025 Elara AI Pty Ltd
+ * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
+ */
+/**
+ * The Allocation's East types (#1371, `Builder Interfaces Spec.md` §6.3). A
+ * day is the board's reading of the app's own rows — each bin the app's row,
+ * with the roles the board reads from it — carried in the fit's and the
+ * check's requests and in the renderer, and stored nowhere: the bins and the
+ * days are the app's records. Beside them, the arrivals and resources an app
+ * gives the board, and the fit's question and answer.
+ *
+ * The types over a day take the app's bin row type, `R`: each is a
+ * constructor, and the same `R` gives the same East type (`isTypeEqual`), so a
+ * row type declared once matches the board's bin kind and the fit's request.
+ *
+ * @packageDocumentation
+ */
+import { ArrayType, BooleanType, DateTimeType, DictType, FloatType, IntegerType, NullType, OptionType, StringType, StructType, VariantType, type EastType } from "@elaraai/east";
+import { TimeStepType } from "@elaraai/east-ui";
+/**
+ * A lane: it takes one bin each `every` (an hour by default), at its offset
+ * past it.
+ *
+ * @property key - Its key, what a bin's lane names: its row's key in the lanes' resource kind
+ * @property label - Its name (`B-1`)
+ * @property offset - How far past each slot's start its bins are booked (`minutes 15`)
+ */
+export declare const AllocationLaneType: StructType<{
+    readonly key: StringType;
+    readonly label: StringType;
+    readonly offset: VariantType<{
+        readonly minutes: FloatType;
+        readonly hours: FloatType;
+        readonly days: FloatType;
+        readonly weeks: FloatType;
+        readonly months: FloatType;
+    }>;
+}>;
+/** Type representing {@link AllocationLaneType}. */
+export type AllocationLaneType = typeof AllocationLaneType;
+/**
+ * A day's status: Schedule's period status, read from the app's days record
+ * (`Schedule.periods`).
+ *
+ * @property draft - An editable day
+ * @property published - A read-only day, and when it was published when the app's published case holds the time
+ * @property other - Another case of the app's status, by its name: read-only
+ */
+export declare const AllocationStatusType: VariantType<{
+    readonly draft: NullType;
+    readonly published: StructType<{
+        readonly at: OptionType<DateTimeType>;
+    }>;
+    readonly other: StringType;
+}>;
+/** Type representing {@link AllocationStatusType}. */
+export type AllocationStatusType = typeof AllocationStatusType;
+/** The fields of a {@link AllocationBinType}, over the app's bin row type `R`. */
+export type AllocationBinFields<R extends EastType> = {
+    lane: StringType;
+    at: DateTimeType;
+    arrival: OptionType<StringType>;
+    quantity: FloatType;
+    kind: OptionType<StringType>;
+    hold: typeof TimeStepType;
+    parts: DictType<StringType, FloatType>;
+    row: R;
+};
+/** A bin over the app's bin row type `R` — what {@link AllocationBinTypeFor} constructs. */
+export type AllocationBinType<R extends EastType> = StructType<AllocationBinFields<R>>;
+/**
+ * One bin, as the board reads it from the app's row (`R`): its roles — one
+ * booking in a lane slot, and the quantity it puts on each resource — beside
+ * the row itself, every field of it.
+ *
+ * @remarks
+ * Composed from the bin kind's roles (its `rows` and `read`) and the row. A
+ * bin keeps what it was booked with — its kind and its hold come from its
+ * arrival when it is booked, as its row's other fields do, and stay with it
+ * when it moves — so a bin can differ from its arrival, as a delivery measured
+ * on arrival does. A reservation books no arrival, and holds no quantity, no
+ * kind and no hold.
+ *
+ * @typeParam R - The app's bin row type
+ * @param row - The app's bin row type
+ * @returns `StructType({ lane, at, arrival, quantity, kind, hold, parts, row })`
+ *
+ * @property lane - Its lane's key
+ * @property at - Its time; a batch's bins follow one minute apart
+ * @property arrival - The arrival it books, by key; `none` for a reservation
+ * @property quantity - Its quantity; 0 for a reservation
+ * @property kind - What it goes with on a resource (its arrival's kind when booked); `none` for a kind with no `kind` role
+ * @property hold - How long a resource holds it from the plan day (its arrival's hold when booked)
+ * @property parts - The quantity on each resource, by key; empty while it is not linked
+ * @property row - The app's row, every field of it
+ */
+export declare function AllocationBinTypeFor<R extends EastType>(row: R): AllocationBinType<R>;
+/** A day over the app's bin row type `R` — what {@link AllocationDayTypeFor} constructs. */
+export type AllocationDayType<R extends EastType> = StructType<{
+    status: AllocationStatusType;
+    bins: DictType<StringType, AllocationBinType<R>>;
+}>;
+/**
+ * One day of the app's bins, as the board reads them: its period's status and
+ * its bins, the drafts in place.
+ *
+ * @typeParam R - The app's bin row type
+ * @param row - The app's bin row type
+ * @returns `StructType({ status, bins })`
+ *
+ * @property status - The day's status, from the app's days record; a draft with no `periods`, or no row for the day
+ * @property bins - The bins whose `at` falls in the day, by their keys
+ */
+export declare function AllocationDayTypeFor<R extends EastType>(row: R): AllocationDayType<R>;
+/**
+ * A span of time, `[from, to)`.
+ *
+ * @property from - Its start
+ * @property to - Its end
+ */
+export declare const AllocationIntervalType: StructType<{
+    readonly from: DateTimeType;
+    readonly to: DateTimeType;
+}>;
+/** Type representing {@link AllocationIntervalType}. */
+export type AllocationIntervalType = typeof AllocationIntervalType;
+/**
+ * Other work on a resource: a job covering the plan day's start makes it busy
+ * until the job ends; one starting later is its next job.
+ *
+ * @property label - Its name (`C-3142`)
+ * @property start - When it starts
+ * @property end - When it ends, and the resource is released
+ */
+export declare const AllocationJobType: StructType<{
+    readonly label: StringType;
+    readonly start: DateTimeType;
+    readonly end: DateTimeType;
+}>;
+/** Type representing {@link AllocationJobType}. */
+export type AllocationJobType = typeof AllocationJobType;
+/**
+ * One line of an arrival's details, shown read-only in a bin's inspector.
+ *
+ * @property label - Its label (`Settings`)
+ * @property value - Its text
+ */
+export declare const AllocationDetailType: StructType<{
+    readonly label: StringType;
+    readonly value: StringType;
+}>;
+/** Type representing {@link AllocationDetailType}. */
+export type AllocationDetailType = typeof AllocationDetailType;
+/**
+ * What the board books from: an arrival, resolved from the app's rows
+ * (`Allocation.arrivals`).
+ *
+ * @property key - Its key in the app's rows, what a bin's `arrival` names
+ * @property label - Its code on cards, chips and lists (`LD-2231`)
+ * @property meta - Its second line (`BRK · R2 · spec MC12`)
+ * @property quantity - Its quantity, booked whole unless split
+ * @property hold - How long a resource holds a bin of it
+ * @property kind - What it goes with: a resource holding the same kind ranks higher in `Allocation.fit`
+ * @property due - When it is due; overdue before the plan day
+ * @property window - Its ready window
+ * @property details - Read-only lines in a bin's inspector
+ */
+export declare const AllocationArrivalType: StructType<{
+    readonly key: StringType;
+    readonly label: StringType;
+    readonly meta: OptionType<StringType>;
+    readonly quantity: FloatType;
+    readonly hold: 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;
+    }>>;
+}>;
+/** Type representing {@link AllocationArrivalType}. */
+export type AllocationArrivalType = typeof AllocationArrivalType;
+/**
+ * A resource bins are allocated to, resolved from the app's rows through its
+ * resource kind's accessors (`Schedule.resources`).
+ *
+ * @property key - Its key in the app's rows, what a bin's `parts` name
+ * @property label - Its name (`K-203`)
+ * @property group - Its group (`Hall B`)
+ * @property meta - Its free line (`Hall B · 40 m³`)
+ * @property note - A line about its next job, after the inspector's next fill
+ * @property min - Its minimum, in the quantity's unit
+ * @property max - Its maximum
+ * @property hold - How long a reservation on it is checked for, and how long it is held when it holds only reservations
+ * @property jobs - Other work on it
+ */
+export declare const AllocationResourceType: 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: 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;
+    }>>;
+}>;
+/** Type representing {@link AllocationResourceType}. */
+export type AllocationResourceType = typeof AllocationResourceType;
+/**
+ * The built-in rules an app may turn off.
+ *
+ * @property under - Whether `Allocation.fit` and `Allocation.check` warn under a resource's minimum
+ */
+export declare const AllocationRulesType: StructType<{
+    readonly under: BooleanType;
+}>;
+/** Type representing {@link AllocationRulesType}. */
+export type AllocationRulesType = typeof AllocationRulesType;
+/**
+ * Everything a fit and the checks read besides the day: the board's
+ * configuration, every arrival and every resource — whatever the narrowing
+ * hides.
+ *
+ * @property lanes - The lanes, in order
+ * @property every - The slot spacing
+ * @property arrivals - Every arrival, by key
+ * @property resources - Every resource, by key
+ * @property rules - The built-in rules
+ * @property unit - The quantity's unit (`m³`), or empty
+ */
+export declare const AllocationContextType: StructType<{
+    readonly lanes: ArrayType<StructType<{
+        readonly key: StringType;
+        readonly label: StringType;
+        readonly offset: VariantType<{
+            readonly minutes: FloatType;
+            readonly hours: FloatType;
+            readonly days: FloatType;
+            readonly weeks: FloatType;
+            readonly months: FloatType;
+        }>;
+    }>>;
+    readonly every: VariantType<{
+        readonly minutes: FloatType;
+        readonly hours: FloatType;
+        readonly days: FloatType;
+        readonly weeks: FloatType;
+        readonly months: FloatType;
+    }>;
+    readonly arrivals: DictType<StringType, StructType<{
+        readonly key: StringType;
+        readonly label: StringType;
+        readonly meta: OptionType<StringType>;
+        readonly quantity: FloatType;
+        readonly hold: 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 resources: DictType<StringType, 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: 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 rules: StructType<{
+        readonly under: BooleanType;
+    }>;
+    readonly unit: StringType;
+}>;
+/** Type representing {@link AllocationContextType}. */
+export type AllocationContextType = typeof AllocationContextType;
+/**
+ * A resource's state on the plan day.
+ *
+ * @property free - It holds nothing and is not busy
+ * @property loading - It holds bins today
+ * @property busy - A job covers the day's start
+ */
+export declare const AllocationLoadStateType: VariantType<{
+    readonly free: NullType;
+    readonly loading: NullType;
+    readonly busy: NullType;
+}>;
+/** Type representing {@link AllocationLoadStateType}. */
+export type AllocationLoadStateType = typeof AllocationLoadStateType;
+/**
+ * A resource's load on the plan day.
+ *
+ * @property resource - The resource's key
+ * @property fill - What its bins put on it
+ * @property bins - How many bins are on it, reservations included
+ * @property hold - From the plan day for its longest bin's hold (its own hold when it holds only reservations); `none` with no bins
+ * @property state - Free, loading or busy
+ */
+export declare const AllocationLoadType: StructType<{
+    readonly resource: StringType;
+    readonly fill: FloatType;
+    readonly bins: IntegerType;
+    readonly hold: OptionType<StructType<{
+        readonly from: DateTimeType;
+        readonly to: DateTimeType;
+    }>>;
+    readonly state: VariantType<{
+        readonly free: NullType;
+        readonly loading: NullType;
+        readonly busy: NullType;
+    }>;
+}>;
+/** Type representing {@link AllocationLoadType}. */
+export type AllocationLoadType = typeof AllocationLoadType;
+/**
+ * A resource's line on the plan day, as its row and its bins' cards show it
+ * (A16, A19).
+ *
+ * @property text - Its line: the load it holds (`11 m³ · max 9 · 2 over`, `reserved · takes 26–48`, with `· 1 d into next job`), `busy until Fri 14`, or what it is and takes when free (`Hall B · 40 m³ · takes 20–40 m³`)
+ * @property tone - `danger` over its maximum, `warning` overlapping its next job or under its minimum, else `neutral`
+ * @property over - Whether it holds more than its maximum
+ * @property under - Whether it holds something, but less than its minimum
+ * @property overlap - Whether its hold runs into its next job
+ * @property next - Its next job: where an overlap starts
+ */
+export declare const AllocationResourceLineType: StructType<{
+    readonly text: StringType;
+    readonly tone: VariantType<{
+        readonly success: NullType;
+        readonly warning: NullType;
+        readonly danger: NullType;
+        readonly info: NullType;
+        readonly neutral: NullType;
+    }>;
+    readonly over: BooleanType;
+    readonly under: BooleanType;
+    readonly overlap: BooleanType;
+    readonly next: OptionType<StructType<{
+        readonly label: StringType;
+        readonly start: DateTimeType;
+        readonly end: DateTimeType;
+    }>>;
+}>;
+/** Type representing {@link AllocationResourceLineType}. */
+export type AllocationResourceLineType = typeof AllocationResourceLineType;
+/**
+ * One quantity on one resource, against the drafted day: what a fit is asked
+ * about, one candidate at a time.
+ *
+ * @property day - The plan day
+ * @property bin - The bin it is for; `none` for an arrival not yet booked and for a new reservation
+ * @property reserve - Whether it reserves a slot (a reservation, or a bin booking no arrival): checked with no quantity, and refused when the resource is full
+ * @property quantity - What the resource would hold of it
+ * @property arrival - Its arrival, if it has one
+ * @property kind - Its kind
+ * @property resource - The resource
+ * @property load - The resource's load as the day stands
+ * @property after - What the resource would hold with it: the other bins' parts, and its quantity
+ * @property hold - From the plan day for the longer of its hold and the resource's other bins' holds
+ * @property spare - The days between the hold's end and the resource's next job; `none` with no next job
+ * @property kindMates - Whether a bin of its kind is already on the resource
+ * @property otherMates - Whether the resource holds other bins, none of its kind
+ * @property rules - The built-in rules
+ * @property unit - The quantity's unit
+ */
+export declare const AllocationCandidateType: 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: 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: 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: VariantType<{
+            readonly free: NullType;
+            readonly loading: NullType;
+            readonly busy: 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;
+}>;
+/** Type representing {@link AllocationCandidateType}. */
+export type AllocationCandidateType = typeof AllocationCandidateType;
+/** Why something does not fit — Schedule's, shared with the Roster. */
+export declare const AllocationRefusalType: StructType<{
+    readonly group: StringType;
+    readonly reason: StringType;
+    readonly measure: VariantType<{
+        readonly none: NullType;
+        readonly amount: StructType<{
+            readonly lead: StringType;
+            readonly value: FloatType;
+        }>;
+        readonly day: StructType<{
+            readonly lead: StringType;
+            readonly at: DateTimeType;
+        }>;
+    }>;
+}>;
+/** Type representing {@link AllocationRefusalType}. */
+export type AllocationRefusalType = typeof AllocationRefusalType;
+/** One verdict of a fit — Schedule's, shared with the Roster. */
+export declare const AllocationFitType: 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: VariantType<{
+            readonly none: NullType;
+            readonly amount: StructType<{
+                readonly lead: StringType;
+                readonly value: FloatType;
+            }>;
+            readonly day: StructType<{
+                readonly lead: StringType;
+                readonly at: DateTimeType;
+            }>;
+        }>;
+    }>;
+}>;
+/** Type representing {@link AllocationFitType}. */
+export type AllocationFitType = typeof AllocationFitType;
+/**
+ * The question a fit answers.
+ *
+ * @property place - Where can this subject — a bin, or an arrival — go with this quantity: a verdict per resource
+ * @property take - What can this resource take: a verdict per bin, one per arrival the day has not booked, and one for reserving an empty slot on it
+ */
+export declare const AllocationFitAskType: VariantType<{
+    readonly place: StructType<{
+        readonly subject: VariantType<{
+            readonly bin: StringType;
+            readonly arrival: StringType;
+        }>;
+        readonly quantity: FloatType;
+    }>;
+    readonly take: StructType<{
+        readonly resource: StringType;
+    }>;
+}>;
+/** Type representing {@link AllocationFitAskType}. */
+export type AllocationFitAskType = typeof AllocationFitAskType;
+/** A fit's request over the app's bin row type `R` — what {@link AllocationFitRequestTypeFor} constructs. */
+export type AllocationFitRequestType<R extends EastType> = StructType<{
+    day: DateTimeType;
+    plan: AllocationDayType<R>;
+    ask: AllocationFitAskType;
+    context: AllocationContextType;
+}>;
+/**
+ * One question to the app's fit, about the drafted day.
+ *
+ * @typeParam R - The app's bin row type
+ * @param row - The app's bin row type
+ * @returns `StructType({ day, plan, ask, context })`
+ *
+ * @property day - The plan day
+ * @property plan - The day as drafted: each bin its roles and its own row
+ * @property ask - The question
+ * @property context - Every arrival and resource, and the board's configuration
+ */
+export declare function AllocationFitRequestTypeFor<R extends EastType>(row: R): AllocationFitRequestType<R>;
+/**
+ * A fit's answer. It echoes its question, so the board matches each answer to
+ * the question it asked.
+ *
+ * @property ask - The question answered
+ * @property resources - A place's verdicts, by resource
+ * @property bins - A take's verdicts, by bin
+ * @property arrivals - A take's verdicts for booking each arrival the day has not booked onto the resource, by arrival (the Table's arrival Chooser, a reservation's Book list)
+ * @property reserve - A take's verdict for reserving an empty slot
+ * @property basis - How the fits are ranked, in words (`ranked by load, kind and spare days`)
+ */
+export declare const AllocationFitResultType: StructType<{
+    readonly ask: VariantType<{
+        readonly place: StructType<{
+            readonly subject: VariantType<{
+                readonly bin: StringType;
+                readonly arrival: StringType;
+            }>;
+            readonly quantity: FloatType;
+        }>;
+        readonly take: StructType<{
+            readonly resource: StringType;
+        }>;
+    }>;
+    readonly resources: DictType<StringType, 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: VariantType<{
+                readonly none: NullType;
+                readonly amount: StructType<{
+                    readonly lead: StringType;
+                    readonly value: FloatType;
+                }>;
+                readonly day: StructType<{
+                    readonly lead: StringType;
+                    readonly at: DateTimeType;
+                }>;
+            }>;
+        }>;
+    }>>;
+    readonly bins: DictType<StringType, 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: VariantType<{
+                readonly none: NullType;
+                readonly amount: StructType<{
+                    readonly lead: StringType;
+                    readonly value: FloatType;
+                }>;
+                readonly day: StructType<{
+                    readonly lead: StringType;
+                    readonly at: DateTimeType;
+                }>;
+            }>;
+        }>;
+    }>>;
+    readonly arrivals: DictType<StringType, 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: VariantType<{
+                readonly none: NullType;
+                readonly amount: StructType<{
+                    readonly lead: StringType;
+                    readonly value: FloatType;
+                }>;
+                readonly day: StructType<{
+                    readonly lead: StringType;
+                    readonly at: DateTimeType;
+                }>;
+            }>;
+        }>;
+    }>>;
+    readonly reserve: OptionType<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: VariantType<{
+                readonly none: NullType;
+                readonly amount: StructType<{
+                    readonly lead: StringType;
+                    readonly value: FloatType;
+                }>;
+                readonly day: StructType<{
+                    readonly lead: StringType;
+                    readonly at: DateTimeType;
+                }>;
+            }>;
+        }>;
+    }>>;
+    readonly basis: StringType;
+}>;
+/** Type representing {@link AllocationFitResultType}. */
+export type AllocationFitResultType = typeof AllocationFitResultType;
+/**
+ * An issue's fix.
+ *
+ * @property choose - Choose a resource for the bin
+ * @property move - Open this bin's resource choices (`Move LD-2205…`)
+ * @property find - Find a fit for the bin's unallocated quantity
+ */
+export declare const AllocationFixType: VariantType<{
+    readonly choose: NullType;
+    readonly move: StringType;
+    readonly find: NullType;
+}>;
+/** Type representing {@link AllocationFixType}. */
+export type AllocationFixType = typeof AllocationFixType;
+/**
+ * What an issue is about.
+ *
+ * @property unlinked - A bin with no resource
+ * @property unallocated - A bin whose parts leave some of it unallocated
+ * @property over - A resource over its maximum
+ * @property under - A resource under its minimum
+ * @property overlap - A resource whose hold runs into its next job
+ * @property custom - One of the app's, by its group's name (`Spec mismatch`)
+ */
+export declare const AllocationIssueKindType: VariantType<{
+    readonly unlinked: NullType;
+    readonly unallocated: NullType;
+    readonly over: NullType;
+    readonly under: NullType;
+    readonly overlap: NullType;
+    readonly custom: StringType;
+}>;
+/** Type representing {@link AllocationIssueKindType}. */
+export type AllocationIssueKindType = typeof AllocationIssueKindType;
+/**
+ * One warning about the drafted day. Issues never block Save or Publish.
+ *
+ * @property kind - What it is about
+ * @property tone - Its tone; warning and danger issues are counted, neutral and info ones listed only
+ * @property title - Its title (`K-207`)
+ * @property detail - Its detail (`44 m³ · max 40 · 4 over · over max`)
+ * @property bin - The bin it is about, if any
+ * @property resource - The resource it is about, if any
+ * @property flag - A bin card's short mark (`≠ spec`)
+ * @property fix - Its fix
+ */
+export declare const AllocationIssueType: StructType<{
+    readonly kind: VariantType<{
+        readonly unlinked: NullType;
+        readonly unallocated: NullType;
+        readonly over: NullType;
+        readonly under: NullType;
+        readonly overlap: NullType;
+        readonly custom: StringType;
+    }>;
+    readonly tone: VariantType<{
+        readonly success: NullType;
+        readonly warning: NullType;
+        readonly danger: NullType;
+        readonly info: NullType;
+        readonly neutral: NullType;
+    }>;
+    readonly title: StringType;
+    readonly detail: StringType;
+    readonly bin: OptionType<StringType>;
+    readonly resource: OptionType<StringType>;
+    readonly flag: OptionType<StringType>;
+    readonly fix: OptionType<VariantType<{
+        readonly choose: NullType;
+        readonly move: StringType;
+        readonly find: NullType;
+    }>>;
+}>;
+/** Type representing {@link AllocationIssueType}. */
+export type AllocationIssueType = typeof AllocationIssueType;
+/** The app's check's input over the app's bin row type `R` — what {@link AllocationCheckContextTypeFor} constructs. */
+export type AllocationCheckContextType<R extends EastType> = StructType<{
+    day: DateTimeType;
+    plan: AllocationDayType<R>;
+    context: AllocationContextType;
+    loads: DictType<StringType, AllocationLoadType>;
+}>;
+/**
+ * What the app's `check` is given: the drafted day and every load.
+ *
+ * @typeParam R - The app's bin row type
+ * @param row - The app's bin row type
+ * @returns `StructType({ day, plan, context, loads })`
+ *
+ * @property day - The plan day
+ * @property plan - The day as drafted: each bin its roles and its own row, which the app's check reads
+ * @property context - Every arrival and resource
+ * @property loads - Every resource's load, by key
+ */
+export declare function AllocationCheckContextTypeFor<R extends EastType>(row: R): AllocationCheckContextType<R>;
+/**
+ * A slot's state.
+ *
+ * @property free - No bin is in it
+ * @property booked - A bin booking an arrival is in it
+ * @property reserved - Only reservations are in it
+ */
+export declare const AllocationSlotStatusType: VariantType<{
+    readonly free: NullType;
+    readonly booked: NullType;
+    readonly reserved: NullType;
+}>;
+/** Type representing {@link AllocationSlotStatusType}. */
+export type AllocationSlotStatusType = typeof AllocationSlotStatusType;
+/**
+ * One lane slot of the plan day: a Table's row, or one per bin of its batch.
+ *
+ * @property lane - Its lane's key
+ * @property at - Its time: the slot's start and its lane's offset
+ * @property status - Free, booked or reserved
+ * @property bins - Its bins, by time
+ */
+export declare const AllocationSlotType: StructType<{
+    readonly lane: StringType;
+    readonly at: DateTimeType;
+    readonly status: VariantType<{
+        readonly free: NullType;
+        readonly booked: NullType;
+        readonly reserved: NullType;
+    }>;
+    readonly bins: ArrayType<StringType>;
+}>;
+/** Type representing {@link AllocationSlotType}. */
+export type AllocationSlotType = typeof AllocationSlotType;
+/**
+ * The board's layout.
+ *
+ * @property timeline - Lanes, links and resources
+ * @property table - One row per slot
+ */
+export declare const AllocationLayoutType: VariantType<{
+    readonly timeline: NullType;
+    readonly table: NullType;
+}>;
+/** Type representing {@link AllocationLayoutType}. */
+export type AllocationLayoutType = typeof AllocationLayoutType;
+//# sourceMappingURL=types.d.ts.map