@khalido/home 0.0.0-stage → 0.1.1

package/dist/connectors/up/index.js

@@ -0,0 +1,213 @@
+import { z } from "zod";
+import { asOf, realClock } from "../../clock.js";
+import { errorText } from "../../connector.js";
+import { envName } from "../../home.js";
+import { poller } from "../../poll.js";
+import { upClient, UpError, } from "./client.js";
+import { anomalies, dollars, inHousehold, isSpend, spendByCategory, spendByMerchant, uncategorised, unknownCategories, } from "./spend.js";
+export { upClient, UpError, } from "./client.js";
+export { dollars, inHousehold, isSpend, merchantKey, notSpend, recurring, spendByCategory, spendByMerchant, uncategorised, unusual, } from "./spend.js";
+export { parseWebhookEvent, SIGNATURE_HEADER, verifyWebhook, } from "./webhook.js";
+/** Poll every 15 minutes: spending moves slowly, and a webhook can nudge a read sooner. */
+export const POLL_MS = 15 * 60_000;
+const ACCOUNT_TYPES = ["TRANSACTIONAL", "SAVER", "HOME_LOAN"];
+const OWNERSHIP_TYPES = ["INDIVIDUAL", "JOINT"];
+/** Which accounts to read: by type and ownership, never by id (e.g. the joint everyday account). All of them when left out. */
+const AccountFilter = z.object({
+    accountType: z.enum(ACCOUNT_TYPES).optional(),
+    ownershipType: z.enum(OWNERSHIP_TYPES).optional(),
+});
+/** Up in a home config: the token's env name, and which accounts count as the household's. */
+export const configSchema = z.looseObject({
+    connector: z.literal("up"),
+    key: envName.describe("env name holding the Up personal access token"),
+    account: AccountFilter.optional().describe("which accounts to read, by type and ownership; every account when left out"),
+    household: z
+        .object({
+        categories: z.array(z.string()).optional(),
+        tags: z.array(z.string()).optional(),
+    })
+        .optional()
+        .describe("what counts as the household's: Up category ids (a parent takes in its children, e.g. home) and tag labels; everything when left out"),
+});
+/** Transactions from the accounts a filter names (every account without one), newest first. The one read the integration and `home up` share. */
+export async function readTransactions(client, account, query = {}, signal) {
+    const accounts = account ? await client.accounts(account, signal) : undefined;
+    if (accounts && !accounts.length)
+        throw new UpError(`no Up account is ${[account.ownershipType, account.accountType].filter(Boolean).join(" ").toLowerCase()}`);
+    const reads = await Promise.all((accounts ?? [undefined]).map((a) => client.transactions({ ...query, accountId: a?.id }, signal)));
+    const transactions = reads
+        .flatMap((r) => r.transactions)
+        .sort((a, b) => ((a.createdAt ?? "") < (b.createdAt ?? "") ? 1 : -1));
+    return {
+        transactions,
+        truncated: reads.some((r) => r.truncated),
+        accounts: accounts?.length ?? 0,
+    };
+}
+/** "2026-10" for each instant, in a time zone. */
+const monthIn = (timeZone) => {
+    const f = new Intl.DateTimeFormat("en-CA", {
+        timeZone,
+        year: "numeric",
+        month: "2-digit",
+    });
+    return (ms) => f.format(ms).slice(0, 7);
+};
+const monthBefore = (month) => {
+    const [y, m] = month.split("-").map(Number);
+    return m === 1 ? `${y - 1}-12` : `${y}-${String(m - 1).padStart(2, "0")}`;
+};
+/** The snapshot from two months of transactions: pure, so tests and a consumer's own reads build the same thing. */
+export function toSnapshot(txs, categories, at) {
+    const monthOf = monthIn(at.timeZone);
+    const thisMonth = monthOf(at.now);
+    const lastMonth = monthBefore(thisMonth);
+    const shared = txs.filter((t) => inHousehold(t, at.household));
+    const byMonth = Map.groupBy(shared, (t) => t.createdAt === undefined ? "" : monthOf(Date.parse(t.createdAt)));
+    const of = (month) => byMonth.get(month) ?? [];
+    const month = (m) => ({
+        month: m,
+        ...spendByCategory(of(m), categories),
+        topMerchants: spendByMerchant(of(m)).slice(0, 5),
+    });
+    // To categorise looks at every purchase in the accounts: a category is how one joins the household.
+    const both = txs.filter((t) => t.createdAt !== undefined &&
+        [thisMonth, lastMonth].includes(monthOf(Date.parse(t.createdAt))));
+    return {
+        asOf: at.asOf,
+        thisMonth: month(thisMonth),
+        lastMonth: month(lastMonth),
+        uncategorised: uncategorised(both).map((t) => t.id),
+        recent: shared
+            .filter(isSpend)
+            .slice(0, 20)
+            .map(({ id, createdAt, description, amountCents, categoryId, parentCategoryId, status, tags, }) => ({
+            id,
+            createdAt,
+            description,
+            amountCents,
+            categoryId,
+            parentCategoryId,
+            status,
+            tags,
+        })),
+        accounts: at.accounts,
+        household: at.household,
+        truncated: at.truncated,
+    };
+}
+/** Up as a home integration: two months of transactions now, then every 15 minutes. Reads only; it never writes. */
+export function up(config) {
+    const client = upClient(config);
+    const clock = config.clock ?? realClock;
+    const poll = poller(clock);
+    return {
+        name: "up",
+        refresh: poll.nudge,
+        async run(signal, update) {
+            let last;
+            while (!signal.aborted) {
+                try {
+                    const now = clock.now();
+                    // 63 days back covers all of last month from any day of this one; months are cut in the home's zone below.
+                    const since = new Date(now - 63 * 86_400_000).toISOString();
+                    const categories = await client.categories(signal);
+                    const read = await readTransactions(client, config.account, { since }, signal);
+                    last = toSnapshot(read.transactions, categories, {
+                        now,
+                        asOf: asOf(clock),
+                        timeZone: config.timeZone,
+                        accounts: read.accounts,
+                        truncated: read.truncated,
+                        household: config.household,
+                    });
+                    const odd = [
+                        ...anomalies(read.transactions),
+                        ...unknownCategories(config.household, categories),
+                        last.truncated
+                            ? "read stopped at its page cap; totals are short"
+                            : "",
+                    ].filter(Boolean);
+                    update({
+                        status: "connected",
+                        anomaly: odd.length ? odd.join("; ") : undefined,
+                        state: last,
+                    });
+                }
+                catch (error) {
+                    if (signal.aborted)
+                        return; // stopped mid-read: not a failure
+                    if (error instanceof UpError && error.status === 401)
+                        return update({
+                            status: "unavailable",
+                            detail: "Up rejected the token",
+                            state: last,
+                        });
+                    update({
+                        status: "disconnected",
+                        detail: errorText(error),
+                        state: last,
+                    });
+                }
+                await poll.wait(POLL_MS, signal);
+            }
+        },
+    };
+}
+const MONTHS = [
+    "Jan",
+    "Feb",
+    "Mar",
+    "Apr",
+    "May",
+    "Jun",
+    "Jul",
+    "Aug",
+    "Sep",
+    "Oct",
+    "Nov",
+    "Dec",
+];
+const monthName = (month) => MONTHS[Number(month.slice(5, 7)) - 1] ?? month;
+/** "Oct so far $2,140 · Sep $1,980 · 3 to categorise": this month's spend against last month's. */
+export function upText(s) {
+    return [
+        `${monthName(s.thisMonth.month)} so far ${dollars(s.thisMonth.cents)}`,
+        `${monthName(s.lastMonth.month)} ${dollars(s.lastMonth.cents)}`,
+        s.uncategorised.length ? `${s.uncategorised.length} to categorise` : "",
+    ]
+        .filter(Boolean)
+        .join(" · ");
+}
+/** One line per parent category this month, largest five: "home $1,030: groceries $620, utilities $410". */
+export const categoryLines = (m) => m.byCategory
+    .slice(0, 5)
+    .map((p) => `${p.name ?? p.id} ${dollars(p.cents)}${p.children.length ? `: ${p.children.map((c) => `${(c.name ?? c.id).toLowerCase()} ${dollars(c.cents)}`).join(", ")}` : ""}`);
+export const manifest = {
+    name: "up",
+    title: "Up Bank",
+    iotClass: "cloud_polling",
+    pollSeconds: POLL_MS / 1000,
+    access: "cloud HTTPS, UP_TOKEN; reads only, writes are `home up` verbs",
+    env: [
+        {
+            name: "UP_TOKEN",
+            example: "up:yeah:xxxxxxxx",
+            what: "Up personal access token (api.up.com.au/getting_started)",
+        },
+        {
+            name: "UP_ACCOUNT",
+            example: "JOINT TRANSACTIONAL",
+            optional: true,
+            what: "which accounts count, by ownership and type; every account when unset",
+        },
+        {
+            name: "UP_HOUSEHOLD",
+            example: "home tag:home",
+            optional: true,
+            what: "what counts as the household's: Up category ids and tag:labels; everything when unset",
+        },
+    ],
+    lines: ({ state }) => state ? [upText(state), ...categoryLines(state.thisMonth)] : [],
+};

package/dist/connectors/up/spend.d.ts

@@ -0,0 +1,78 @@
+import type { Category, Transaction } from "./client.ts";
+/** Why a transaction is not spend, or undefined when it is. The one place the rule lives. */
+export declare function notSpend(t: Transaction): string | undefined;
+/** Settled money out to someone else: not held, not a transfer, cover, forward or round-up between your own accounts. */
+export declare const isSpend: (t: Transaction) => boolean;
+/** A window of time by the transaction's creation, `[since, until)` as ISO strings; either end open. */
+export type Window = {
+    since?: string;
+    until?: string;
+};
+export type CategorySpend = {
+    id: string;
+    name?: string;
+    cents: number;
+    count: number;
+    children: {
+        id: string;
+        name?: string;
+        cents: number;
+        count: number;
+    }[];
+};
+export type SpendSummary = {
+    cents: number;
+    count: number;
+    excluded: {
+        count: number;
+        cents: number;
+    };
+    uncategorisedCents: number;
+    byCategory: CategorySpend[];
+};
+/** Spend in a window grouped by Up's parent and child categories, with what was excluded counted and summed. */
+export declare function spendByCategory(txs: Transaction[], categories: Category[], window?: Window): SpendSummary;
+/** A merchant's name as grouped: lower case, digits and punctuation dropped ("WOOLWORTHS 1234" and "Woolworths" are one); a name with no letters stays itself. */
+export declare const merchantKey: (description?: string) => string;
+export type MerchantSpend = {
+    merchant: string;
+    cents: number;
+    count: number;
+};
+/** Spend per merchant, largest first; the merchant shown as its latest description. */
+export declare function spendByMerchant(txs: Transaction[], window?: Window): MerchantSpend[];
+/** What the household shares: Up category ids (a parent takes in its children) and tag labels. */
+export type Household = {
+    categories?: string[];
+    tags?: string[];
+};
+/** The one rule for what counts as the household's: a listed category or its parent, or a listed tag. Everything counts without a list. */
+export declare function inHousehold(t: Transaction, h: Household | undefined): boolean;
+/** Household categories Up does not have, said in words: a typo would otherwise count nothing, silently. */
+export declare const unknownCategories: (h: Household | undefined, categories: Category[]) => string[];
+/** Spend Up lets you categorise that has no category yet. Money in (salary, a payment received) is categorisable too, but is not spend. */
+export declare const uncategorised: (txs: Transaction[]) => Transaction[];
+export type Recurring = {
+    merchant: string;
+    months: number;
+    medianCents: number;
+    lastAt?: string;
+};
+/**
+ * A heuristic, since Up has no subscription endpoint: the same merchant in three or more distinct months, every amount
+ * within 20% of that merchant's median.
+ */
+export declare function recurring(txs: Transaction[], timeZone?: string): Recurring[];
+export type Unusual = {
+    id: string;
+    merchant: string;
+    cents: number;
+    medianCents: number;
+    at?: string;
+};
+/** Spend well above that merchant's usual: more than twice the median of at least three earlier purchases there. */
+export declare function unusual(txs: Transaction[]): Unusual[];
+/** Readings that look wrong, said in words: never fixed here. */
+export declare function anomalies(txs: Transaction[]): string[];
+/** Cents as dollars for reading: "$1,234" (whole dollars) or "$12.50". Display only. */
+export declare const dollars: (cents: number, whole?: boolean) => string;

package/dist/connectors/up/spend.js

@@ -0,0 +1,213 @@
+// Pure helpers over transactions, one owner per number. Amounts are cents; spend is reported as a positive number.
+/**
+ * Up's own movements between your accounts that carry no `transferAccount` (unconfirmed: matched by description, the
+ * way up-finance-skills does). Most movements do carry it and are caught by that field.
+ */
+const OWN_MOVEMENT = [
+    /^cover from /i,
+    /^forward to /i,
+    /^round up\b/i,
+    /^quick save transfer/i,
+]; // not "Transfer to …": paying someone else is spend
+/** Why a transaction is not spend, or undefined when it is. The one place the rule lives. */
+export function notSpend(t) {
+    if (t.status !== "SETTLED")
+        return "held";
+    if (t.amountCents === undefined)
+        return "no amount";
+    if (t.amountCents >= 0)
+        return "money in";
+    if (t.transferAccountId)
+        return "transfer between your accounts";
+    if (t.description && OWN_MOVEMENT.some((r) => r.test(t.description)))
+        return "cover, forward or round-up";
+    return undefined;
+}
+/** Settled money out to someone else: not held, not a transfer, cover, forward or round-up between your own accounts. */
+export const isSpend = (t) => notSpend(t) === undefined;
+/** Money spent, as a positive number of cents. */
+const spent = (t) => -(t.amountCents ?? 0);
+const inWindow = (t, w = {}) => {
+    if (!w.since && !w.until)
+        return true;
+    const at = Date.parse(t.createdAt ?? ""); // Up's times carry an offset (+11:00); compare instants, not text
+    return ((!w.since || at >= Date.parse(w.since)) &&
+        (!w.until || at < Date.parse(w.until)));
+};
+/** Money out that the rule leaves out (a transfer, cover, forward or round-up), counted so a total can be checked. */
+const MOVED = new Set([
+    "transfer between your accounts",
+    "cover, forward or round-up",
+]);
+/** Spend in a window grouped by Up's parent and child categories, with what was excluded counted and summed. */
+export function spendByCategory(txs, categories, window) {
+    const name = new Map(categories.map((c) => [c.id, c.name]));
+    const parentOf = new Map(categories.map((c) => [c.id, c.parentId]));
+    const parents = new Map();
+    const summary = {
+        cents: 0,
+        count: 0,
+        excluded: { count: 0, cents: 0 },
+        uncategorisedCents: 0,
+        byCategory: [],
+    };
+    for (const t of txs) {
+        if (!inWindow(t, window))
+            continue;
+        const why = notSpend(t);
+        if (why) {
+            if (MOVED.has(why))
+                (summary.excluded.count++, (summary.excluded.cents += spent(t)));
+            continue;
+        }
+        summary.cents += spent(t);
+        summary.count++;
+        if (!t.categoryId) {
+            summary.uncategorisedCents += spent(t);
+            continue;
+        }
+        const parentId = t.parentCategoryId ?? parentOf.get(t.categoryId) ?? t.categoryId;
+        const p = parents.get(parentId) ?? {
+            id: parentId,
+            name: name.get(parentId),
+            cents: 0,
+            count: 0,
+            children: [],
+        };
+        parents.set(parentId, p);
+        p.cents += spent(t);
+        p.count++;
+        if (t.categoryId !== parentId) {
+            let c = p.children.find((x) => x.id === t.categoryId);
+            if (!c)
+                p.children.push((c = {
+                    id: t.categoryId,
+                    name: name.get(t.categoryId),
+                    cents: 0,
+                    count: 0,
+                }));
+            c.cents += spent(t);
+            c.count++;
+        }
+    }
+    summary.byCategory = [...parents.values()].sort((a, b) => b.cents - a.cents);
+    for (const p of summary.byCategory)
+        p.children.sort((a, b) => b.cents - a.cents);
+    return summary;
+}
+/** A merchant's name as grouped: lower case, digits and punctuation dropped ("WOOLWORTHS 1234" and "Woolworths" are one); a name with no letters stays itself. */
+export const merchantKey = (description = "") => description
+    .toLowerCase()
+    .replace(/[^\p{L} ]+/gu, " ")
+    .replace(/\s+/g, " ")
+    .trim() || description;
+/** Spend per merchant, largest first; the merchant shown as its latest description. */
+export function spendByMerchant(txs, window) {
+    const by = new Map();
+    for (const t of txs) {
+        if (!inWindow(t, window) || !isSpend(t))
+            continue;
+        const key = merchantKey(t.description);
+        const m = by.get(key) ?? {
+            merchant: t.description ?? "?",
+            cents: 0,
+            count: 0,
+        };
+        by.set(key, m);
+        m.cents += spent(t);
+        m.count++;
+    }
+    return [...by.values()].sort((a, b) => b.cents - a.cents);
+}
+/** The one rule for what counts as the household's: a listed category or its parent, or a listed tag. Everything counts without a list. */
+export function inHousehold(t, h) {
+    if (!h?.categories?.length && !h?.tags?.length)
+        return true;
+    const byCategory = h.categories?.some((c) => c === t.categoryId || c === t.parentCategoryId) ??
+        false;
+    return byCategory || (t.tags?.some((tag) => h.tags?.includes(tag)) ?? false);
+}
+/** Household categories Up does not have, said in words: a typo would otherwise count nothing, silently. */
+export const unknownCategories = (h, categories) => (h?.categories ?? [])
+    .filter((c) => !categories.some((k) => k.id === c))
+    .map((c) => `household category ${c} is not an Up category`);
+/** Spend Up lets you categorise that has no category yet. Money in (salary, a payment received) is categorisable too, but is not spend. */
+export const uncategorised = (txs) => txs.filter((t) => t.isCategorizable && !t.categoryId && isSpend(t));
+const median = (xs) => {
+    const s = [...xs].sort((a, b) => a - b);
+    const m = Math.floor(s.length / 2);
+    return s.length % 2 ? s[m] : (s[m - 1] + s[m]) / 2;
+};
+/**
+ * A heuristic, since Up has no subscription endpoint: the same merchant in three or more distinct months, every amount
+ * within 20% of that merchant's median.
+ */
+export function recurring(txs, timeZone) {
+    const month = new Intl.DateTimeFormat("en-CA", {
+        timeZone,
+        year: "numeric",
+        month: "2-digit",
+    });
+    const by = new Map();
+    for (const t of txs) {
+        if (!isSpend(t) || !t.createdAt)
+            continue;
+        const key = merchantKey(t.description);
+        by.set(key, [...(by.get(key) ?? []), t]);
+    }
+    const out = [];
+    for (const list of by.values()) {
+        const months = new Set(list.map((t) => month.format(new Date(t.createdAt))));
+        if (months.size < 3)
+            continue;
+        const mid = median(list.map(spent));
+        if (!list.every((t) => Math.abs(spent(t) - mid) <= mid * 0.2))
+            continue;
+        const latest = list.reduce((a, b) => (a.createdAt > b.createdAt ? a : b));
+        out.push({
+            merchant: latest.description ?? "?",
+            months: months.size,
+            medianCents: mid,
+            lastAt: latest.createdAt,
+        });
+    }
+    return out.sort((a, b) => b.medianCents - a.medianCents);
+}
+/** Spend well above that merchant's usual: more than twice the median of at least three earlier purchases there. */
+export function unusual(txs) {
+    const sorted = txs
+        .filter((t) => isSpend(t) && t.createdAt)
+        .sort((a, b) => (a.createdAt < b.createdAt ? -1 : 1));
+    const seen = new Map();
+    const out = [];
+    for (const t of sorted) {
+        const key = merchantKey(t.description);
+        const prior = seen.get(key) ?? [];
+        if (prior.length >= 3) {
+            const mid = median(prior);
+            if (spent(t) > 2 * mid)
+                out.push({
+                    id: t.id,
+                    merchant: t.description ?? "?",
+                    cents: spent(t),
+                    medianCents: mid,
+                    at: t.createdAt,
+                });
+        }
+        seen.set(key, [...prior, spent(t)]);
+    }
+    return out;
+}
+/** Readings that look wrong, said in words: never fixed here. */
+export function anomalies(txs) {
+    const out = [];
+    const noAmount = txs.filter((t) => t.amountCents === undefined).length;
+    if (noAmount)
+        out.push(`${noAmount} transaction(s) without an amount`);
+    const foreign = txs.filter((t) => t.currency !== undefined && t.currency !== "AUD").length;
+    if (foreign)
+        out.push(`${foreign} transaction(s) not in AUD`);
+    return out;
+}
+/** Cents as dollars for reading: "$1,234" (whole dollars) or "$12.50". Display only. */
+export const dollars = (cents, whole = true) => `${cents < 0 ? "-" : ""}$${(Math.abs(cents) / 100).toLocaleString("en-AU", { minimumFractionDigits: whole ? 0 : 2, maximumFractionDigits: whole ? 0 : 2 })}`;

package/dist/connectors/up/webhook.d.ts

@@ -0,0 +1,13 @@
+/** The header Up signs each event with: the SHA-256 HMAC of the raw body under the webhook's `secretKey`, hex. */
+export declare const SIGNATURE_HEADER = "X-Up-Authenticity-Signature";
+/** True when `signature` (the header's value) is the HMAC of `rawBody` under `secret`. Compares in constant time. */
+export declare function verifyWebhook(rawBody: string | Uint8Array, signature: string | null | undefined, secret: string): Promise<boolean>;
+/** One webhook event: its type ("TRANSACTION_CREATED", "TRANSACTION_SETTLED", "TRANSACTION_DELETED", "PING") and the transaction it names. */
+export type WebhookEvent = {
+    id?: string;
+    type?: string;
+    createdAt?: string;
+    transactionId?: string;
+};
+/** The event in a webhook body. Fields Up leaves out stay undefined; a body that is not JSON throws. */
+export declare function parseWebhookEvent(body: unknown): WebhookEvent;

package/dist/connectors/up/webhook.js

@@ -0,0 +1,32 @@
+// Receiving Up's webhooks is the consumer's job (it needs a public URL); these two pure functions are all it needs from
+// here. The handler: verify, parse, then `home.refresh("up")`. Web Crypto only, so it runs on Bun, Node and workers.
+/** The header Up signs each event with: the SHA-256 HMAC of the raw body under the webhook's `secretKey`, hex. */
+export const SIGNATURE_HEADER = "X-Up-Authenticity-Signature";
+const hex = (bytes) => [...new Uint8Array(bytes)]
+    .map((b) => b.toString(16).padStart(2, "0"))
+    .join("");
+/** True when `signature` (the header's value) is the HMAC of `rawBody` under `secret`. Compares in constant time. */
+export async function verifyWebhook(rawBody, signature, secret) {
+    if (!signature)
+        return false;
+    const enc = new TextEncoder();
+    const key = await crypto.subtle.importKey("raw", enc.encode(secret), { name: "HMAC", hash: "SHA-256" }, false, ["sign"]);
+    const body = typeof rawBody === "string" ? enc.encode(rawBody) : rawBody;
+    const want = hex(await crypto.subtle.sign("HMAC", key, body));
+    const got = signature.trim().toLowerCase();
+    let diff = want.length ^ got.length;
+    for (let i = 0; i < want.length; i++)
+        diff |= want.charCodeAt(i) ^ (got.charCodeAt(i) || 0);
+    return diff === 0;
+}
+/** The event in a webhook body. Fields Up leaves out stay undefined; a body that is not JSON throws. */
+export function parseWebhookEvent(body) {
+    const json = (typeof body === "string" ? JSON.parse(body) : body);
+    const d = json?.data;
+    return {
+        id: d?.id,
+        type: d?.attributes?.eventType,
+        createdAt: d?.attributes?.createdAt,
+        transactionId: d?.relationships?.transaction?.data?.id,
+    };
+}

package/dist/connectors/weather/blocks.d.ts

@@ -0,0 +1,51 @@
+import { type Condition, type WeatherHourly } from "./source.ts";
+/** One part of a day: its name and the local hours it covers, `from` up to `to` (0–24, within one day). */
+export type BlockDef = {
+    name: string;
+    from: number;
+    to: number;
+};
+/** The parts of a day by default, by the local hour each starts in: KO's call. A consumer passes its own to `dayBlocks`. */
+export declare const BLOCKS: readonly BlockDef[];
+/**
+ * One part of a day from the hourly forecast: `hours` is how many hours it summarises, fewer than its length when it is under way or
+ * the source left hours out. `rainChance` is the highest hour's, `rainMm` the sum (missing if any hour lacks one), `condition` the worst hour's.
+ * `late`: it starts after its part of the day does (under way, or the source began later).
+ */
+export type DayBlock = {
+    name: string;
+    date: string;
+    from: string;
+    to: string;
+    hours: number;
+    late?: boolean;
+    minC?: number;
+    maxC?: number;
+    rainChance?: number;
+    rainMm?: number;
+    windKmh?: number;
+    gustKmh?: number;
+    uvIndex?: number;
+    condition?: Condition;
+};
+export type DayBlocks = {
+    source: string;
+    today: DayBlock[];
+    tomorrow: DayBlock[];
+};
+/**
+ * The rest of today and tomorrow in `blocks` (`BLOCKS` by default), from the hourly forecast, in the home's time zone (the
+ * runtime's when left out). The one owner: the integration, `home weather` and a consumer with its own clock all call
+ * `dayBlocks(state.hourly, now, timeZone)`. An hour counts while it has not ended; a part with no hours left is left out.
+ * Throws on a block outside 0–24 or ending before it starts.
+ */
+export declare function dayBlocks(hourly: WeatherHourly | undefined, at: number, timeZone?: string, blocks?: readonly BlockDef[]): DayBlocks | undefined;
+/** Throw on blocks a day cannot hold: whole hours within 0–24, each ending after it starts. */
+export declare function checkBlocks(blocks: readonly BlockDef[]): void;
+/** The UV index from which a block's text names it: 3, where sun protection starts to be advised (WHO's "moderate"). A display rule. */
+export declare const UV_SHOWN = 3;
+/**
+ * "afternoon from 16:00 17–19 °C, showers, rain 40% 1.2 mm, wind 25 km/h gusting 40, UV 8". `from` shows when the part is
+ * under way or short; UV shows from `UV_SHOWN`.
+ */
+export declare function blockText(b: DayBlock, timeZone?: string): string;