@khalido/home 0.0.0-stage → 0.1.1

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

@@ -0,0 +1,183 @@
+import { z } from "zod";
+import { ConnectorError } from "../../connector.ts";
+/** A failed Up call. `status` 401 means the token is wrong or revoked; 429 the rate limit (unpublished: read `X-RateLimit-Remaining`). */
+export declare class UpError extends ConnectorError {
+}
+declare const TransactionResource: z.ZodObject<{
+    id: z.ZodString;
+    attributes: z.ZodOptional<z.ZodObject<{
+        status: z.ZodOptional<z.ZodString>;
+        rawText: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        description: z.ZodOptional<z.ZodString>;
+        message: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        isCategorizable: z.ZodOptional<z.ZodBoolean>;
+        holdInfo: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            amount: z.ZodOptional<z.ZodObject<{
+                currencyCode: z.ZodOptional<z.ZodString>;
+                value: z.ZodOptional<z.ZodString>;
+                valueInBaseUnits: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$loose>>;
+        }, z.core.$loose>>>;
+        roundUp: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            amount: z.ZodOptional<z.ZodObject<{
+                currencyCode: z.ZodOptional<z.ZodString>;
+                value: z.ZodOptional<z.ZodString>;
+                valueInBaseUnits: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$loose>>;
+        }, z.core.$loose>>>;
+        cashback: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            amount: z.ZodOptional<z.ZodObject<{
+                currencyCode: z.ZodOptional<z.ZodString>;
+                value: z.ZodOptional<z.ZodString>;
+                valueInBaseUnits: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$loose>>;
+        }, z.core.$loose>>>;
+        amount: z.ZodOptional<z.ZodObject<{
+            currencyCode: z.ZodOptional<z.ZodString>;
+            value: z.ZodOptional<z.ZodString>;
+            valueInBaseUnits: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$loose>>;
+        foreignAmount: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            currencyCode: z.ZodOptional<z.ZodString>;
+            value: z.ZodOptional<z.ZodString>;
+            valueInBaseUnits: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$loose>>>;
+        settledAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        createdAt: z.ZodOptional<z.ZodString>;
+        transactionType: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        note: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            text: z.ZodOptional<z.ZodString>;
+        }, z.core.$loose>>>;
+        performingCustomer: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+            displayName: z.ZodOptional<z.ZodString>;
+        }, z.core.$loose>>>;
+        deepLinkURL: z.ZodOptional<z.ZodString>;
+    }, z.core.$loose>>;
+    relationships: z.ZodOptional<z.ZodObject<{
+        account: z.ZodOptional<z.ZodObject<{
+            data: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                id: z.ZodString;
+            }, z.core.$loose>>>;
+        }, z.core.$loose>>;
+        transferAccount: z.ZodOptional<z.ZodObject<{
+            data: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                id: z.ZodString;
+            }, z.core.$loose>>>;
+        }, z.core.$loose>>;
+        category: z.ZodOptional<z.ZodObject<{
+            data: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                id: z.ZodString;
+            }, z.core.$loose>>>;
+        }, z.core.$loose>>;
+        parentCategory: z.ZodOptional<z.ZodObject<{
+            data: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+                id: z.ZodString;
+            }, z.core.$loose>>>;
+        }, z.core.$loose>>;
+        tags: z.ZodOptional<z.ZodObject<{
+            data: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+            }, z.core.$loose>>>;
+        }, z.core.$loose>>;
+    }, z.core.$loose>>;
+}, z.core.$loose>;
+/** One transaction as the library keeps it: amounts in cents (Up's base units), ids flattened, nothing derived. */
+export type Transaction = {
+    id: string;
+    status?: string;
+    description?: string;
+    rawText?: string;
+    message?: string;
+    amountCents?: number;
+    currency?: string;
+    foreignCents?: number;
+    foreignCurrency?: string;
+    heldCents?: number;
+    roundUpCents?: number;
+    cashbackCents?: number;
+    isCategorizable?: boolean;
+    createdAt?: string;
+    settledAt?: string;
+    transactionType?: string;
+    note?: string;
+    performedBy?: string;
+    deepLink?: string;
+    accountId?: string;
+    transferAccountId?: string;
+    categoryId?: string;
+    parentCategoryId?: string;
+    tags: string[];
+};
+export type Category = {
+    id: string;
+    name?: string;
+    parentId?: string;
+};
+export type Account = {
+    id: string;
+    displayName?: string;
+    accountType?: string;
+    ownershipType?: string;
+    balanceCents?: number;
+};
+export type Webhook = {
+    id: string;
+    url?: string;
+    description?: string;
+    createdAt?: string;
+    secretKey?: string;
+};
+export type WebhookLog = {
+    id: string;
+    deliveryStatus?: string;
+    createdAt?: string;
+    statusCode?: number;
+};
+/** Up's transaction resource to the library's shape. */
+export declare function toTransaction(r: z.infer<typeof TransactionResource>): Transaction;
+export type TransactionQuery = {
+    since?: string;
+    until?: string;
+    status?: "HELD" | "SETTLED";
+    category?: string;
+    tag?: string;
+    accountId?: string;
+    limit?: number;
+    pageCap?: number;
+};
+/** The Up client: the token comes in, nothing is stored. Reads are GETs; the writes are the three Up allows, each re-reading what Up now holds. */
+export declare function upClient(options: {
+    token: string;
+    fetch: typeof fetch;
+}): {
+    /** 200 when the token is good. */
+    ping(signal?: AbortSignal): Promise<void>;
+    accounts(filter?: {
+        accountType?: string;
+        ownershipType?: string;
+    }, signal?: AbortSignal): Promise<Account[]>;
+    /** Transactions newest first, following cursors. A cut-off result says so in `truncated`, so it never looks complete. */
+    transactions(query?: TransactionQuery, signal?: AbortSignal): Promise<{
+        transactions: Transaction[];
+        truncated: boolean;
+    }>;
+    transaction: (txId: string, signal?: AbortSignal) => Promise<Transaction>;
+    categories(signal?: AbortSignal): Promise<Category[]>;
+    tags(signal?: AbortSignal): Promise<string[]>;
+    /** Set a child category, or `null` to clear it. Returns the transaction as Up now holds it. */
+    setCategory(txId: string, categoryId: string | null, signal?: AbortSignal): Promise<Transaction>;
+    /** Add tags by label (at most 6 per transaction; a duplicate is ignored). Returns the transaction as Up now holds it. */
+    addTags(txId: string, labels: string[], signal?: AbortSignal): Promise<Transaction>;
+    /** Remove tags by label (an absent one is ignored). Returns the transaction as Up now holds it. */
+    removeTags(txId: string, labels: string[], signal?: AbortSignal): Promise<Transaction>;
+    webhooks(signal?: AbortSignal): Promise<Webhook[]>;
+    webhook(webhookId: string, signal?: AbortSignal): Promise<Webhook>;
+    webhookLogs(webhookId: string, signal?: AbortSignal): Promise<WebhookLog[]>;
+    /** Create a webhook. Its `secretKey` comes back this once: the caller keeps it; this client never stores or logs it. */
+    createWebhook(hookUrl: string, description?: string, signal?: AbortSignal): Promise<Webhook>;
+    deleteWebhook(webhookId: string, signal?: AbortSignal): Promise<void>;
+    /** Ask Up to send a PING event to the webhook. */
+    pingWebhook(webhookId: string, signal?: AbortSignal): Promise<void>;
+};
+export type UpClient = ReturnType<typeof upClient>;
+export {};

package/dist/connectors/up/client.js

@@ -0,0 +1,308 @@
+import { z } from "zod";
+import { ConnectorError, fetchTimeout, getJson } from "../../connector.js";
+// Up Bank's API v1 (https://developer.up.com.au/, spec github.com/up-banking/api, v1/openapi.json). Field names checked
+// against one live read, 2026-10-16. Every field optional so a change degrades a reading rather than throwing.
+const BASE = "https://api.up.com.au/api/v1";
+/** A failed Up call. `status` 401 means the token is wrong or revoked; 429 the rate limit (unpublished: read `X-RateLimit-Remaining`). */
+export class UpError extends ConnectorError {
+}
+const Money = z.looseObject({
+    currencyCode: z.string().optional(),
+    value: z.string().optional(),
+    valueInBaseUnits: z.number().optional(),
+});
+const Ref = z.looseObject({
+    data: z.looseObject({ id: z.string() }).nullable().optional(),
+});
+const TransactionResource = z.looseObject({
+    id: z.string(),
+    attributes: z
+        .looseObject({
+        status: z.string().optional(), // "HELD" | "SETTLED"
+        rawText: z.string().nullable().optional(),
+        description: z.string().optional(),
+        message: z.string().nullable().optional(),
+        isCategorizable: z.boolean().optional(),
+        holdInfo: z
+            .looseObject({ amount: Money.optional() })
+            .nullable()
+            .optional(),
+        roundUp: z
+            .looseObject({ amount: Money.optional() })
+            .nullable()
+            .optional(),
+        cashback: z
+            .looseObject({ amount: Money.optional() })
+            .nullable()
+            .optional(),
+        amount: Money.optional(),
+        foreignAmount: Money.nullable().optional(),
+        settledAt: z.string().nullable().optional(),
+        createdAt: z.string().optional(),
+        transactionType: z.string().nullable().optional(),
+        note: z
+            .looseObject({ text: z.string().optional() })
+            .nullable()
+            .optional(),
+        performingCustomer: z
+            .looseObject({ displayName: z.string().optional() })
+            .nullable()
+            .optional(),
+        deepLinkURL: z.string().optional(),
+    })
+        .optional(),
+    relationships: z
+        .looseObject({
+        account: Ref.optional(),
+        transferAccount: Ref.optional(),
+        category: Ref.optional(),
+        parentCategory: Ref.optional(),
+        tags: z
+            .looseObject({
+            data: z.array(z.looseObject({ id: z.string() })).optional(),
+        })
+            .optional(),
+    })
+        .optional(),
+});
+const Page = (item) => z.looseObject({
+    data: z.array(item),
+    links: z.looseObject({ next: z.string().nullable().optional() }).optional(),
+});
+const One = (item) => z.looseObject({ data: item });
+const CategoryResource = z.looseObject({
+    id: z.string(),
+    attributes: z.looseObject({ name: z.string().optional() }).optional(),
+    relationships: z.looseObject({ parent: Ref.optional() }).optional(),
+});
+const AccountResource = z.looseObject({
+    id: z.string(),
+    attributes: z
+        .looseObject({
+        displayName: z.string().optional(),
+        accountType: z.string().optional(),
+        ownershipType: z.string().optional(),
+        balance: Money.optional(),
+    })
+        .optional(),
+});
+const WebhookResource = z.looseObject({
+    id: z.string(),
+    attributes: z
+        .looseObject({
+        url: z.string().optional(),
+        description: z.string().nullable().optional(),
+        secretKey: z.string().optional(),
+        createdAt: z.string().optional(),
+    })
+        .optional(),
+});
+const LogResource = z.looseObject({
+    id: z.string(),
+    attributes: z
+        .looseObject({
+        deliveryStatus: z.string().optional(),
+        createdAt: z.string().optional(),
+        response: z
+            .looseObject({ statusCode: z.number().optional() })
+            .nullable()
+            .optional(),
+    })
+        .optional(),
+});
+const id = (r) => r?.data?.id ?? undefined;
+const nul = (v) => v ?? undefined;
+/** Up's transaction resource to the library's shape. */
+export function toTransaction(r) {
+    const a = r.attributes ?? {};
+    const rel = r.relationships ?? {};
+    return {
+        id: r.id,
+        status: a.status,
+        description: a.description,
+        rawText: nul(a.rawText),
+        message: nul(a.message),
+        amountCents: a.amount?.valueInBaseUnits,
+        currency: a.amount?.currencyCode,
+        foreignCents: nul(a.foreignAmount)?.valueInBaseUnits,
+        foreignCurrency: nul(a.foreignAmount)?.currencyCode,
+        heldCents: nul(a.holdInfo)?.amount?.valueInBaseUnits,
+        roundUpCents: nul(a.roundUp)?.amount?.valueInBaseUnits,
+        cashbackCents: nul(a.cashback)?.amount?.valueInBaseUnits,
+        isCategorizable: a.isCategorizable,
+        createdAt: a.createdAt,
+        settledAt: nul(a.settledAt),
+        transactionType: nul(a.transactionType),
+        note: nul(a.note)?.text,
+        performedBy: nul(a.performingCustomer)?.displayName,
+        deepLink: a.deepLinkURL,
+        accountId: id(rel.account),
+        transferAccountId: id(rel.transferAccount),
+        categoryId: id(rel.category),
+        parentCategoryId: id(rel.parentCategory),
+        tags: rel.tags?.data?.map((t) => t.id) ?? [],
+    };
+}
+/** The Up client: the token comes in, nothing is stored. Reads are GETs; the writes are the three Up allows, each re-reading what Up now holds. */
+export function upClient(options) {
+    const headers = {
+        authorization: `Bearer ${options.token}`,
+        accept: "application/json",
+    };
+    const url = (path) => path.startsWith("https://") ? path : `${BASE}${path}`;
+    const get = (path, schema, signal) => getJson(options.fetch, url(path), {
+        init: { headers },
+        signal,
+        schema,
+        error: UpError,
+    });
+    /** A write: JSON in, the status checked, the body (if any) returned. Up answers 204 to category and tag writes. */
+    async function send(method, path, body, signal) {
+        const init = {
+            method,
+            headers: {
+                ...headers,
+                ...(body === undefined ? {} : { "content-type": "application/json" }),
+            },
+            body: body === undefined ? undefined : JSON.stringify(body),
+        };
+        const res = await fetchTimeout(options.fetch, url(path), init, { signal });
+        if (!res.ok)
+            throw new UpError(`HTTP ${res.status} on ${method} ${new URL(url(path)).pathname}`, { status: res.status });
+        return res.status === 204 ? undefined : res.json();
+    }
+    /** Follow `links.next` until `limit` items or `pageCap` pages; `truncated` says more were there. */
+    async function pages(path, item, limit, pageCap, signal) {
+        const out = [];
+        let next = path;
+        let n = 0;
+        while (next && out.length < limit && n < pageCap) {
+            const page = await get(next, Page(item), signal);
+            out.push(...page.data);
+            next = page.links?.next ?? undefined;
+            n++;
+        }
+        return {
+            items: out.slice(0, limit),
+            truncated: next !== undefined || out.length > limit,
+        };
+    }
+    const transaction = async (txId, signal) => toTransaction((await get(`/transactions/${encodeURIComponent(txId)}`, One(TransactionResource), signal)).data);
+    const tagBody = (labels) => ({
+        data: labels.map((l) => ({ type: "tags", id: l })),
+    });
+    return {
+        /** 200 when the token is good. */
+        async ping(signal) {
+            await get("/util/ping", z.unknown(), signal);
+        },
+        async accounts(filter = {}, signal) {
+            const q = new URLSearchParams({ "page[size]": "100" });
+            if (filter.accountType)
+                q.set("filter[accountType]", filter.accountType);
+            if (filter.ownershipType)
+                q.set("filter[ownershipType]", filter.ownershipType);
+            const { items } = await pages(`/accounts?${q}`, AccountResource, 1000, 10, signal);
+            return items.map((r) => ({
+                id: r.id,
+                displayName: r.attributes?.displayName,
+                accountType: r.attributes?.accountType,
+                ownershipType: r.attributes?.ownershipType,
+                balanceCents: r.attributes?.balance?.valueInBaseUnits,
+            }));
+        },
+        /** Transactions newest first, following cursors. A cut-off result says so in `truncated`, so it never looks complete. */
+        async transactions(query = {}, signal) {
+            const limit = query.limit ?? 1000;
+            const q = new URLSearchParams({
+                "page[size]": String(Math.min(100, limit)),
+            });
+            for (const [k, v] of [
+                ["since", query.since],
+                ["until", query.until],
+                ["status", query.status],
+                ["category", query.category],
+                ["tag", query.tag],
+            ])
+                if (v)
+                    q.set(`filter[${k}]`, v);
+            const base = query.accountId
+                ? `/accounts/${encodeURIComponent(query.accountId)}/transactions`
+                : "/transactions";
+            const { items, truncated } = await pages(`${base}?${q}`, TransactionResource, limit, query.pageCap ?? 20, signal);
+            return { transactions: items.map(toTransaction), truncated };
+        },
+        transaction,
+        async categories(signal) {
+            const { data } = await get("/categories", z.looseObject({ data: z.array(CategoryResource) }), signal);
+            return data.map((c) => ({
+                id: c.id,
+                name: c.attributes?.name,
+                parentId: id(c.relationships?.parent),
+            }));
+        },
+        async tags(signal) {
+            return (await pages("/tags?page[size]=100", z.looseObject({ id: z.string() }), 1000, 10, signal)).items.map((t) => t.id);
+        },
+        // Writes. The integration never calls these; `home up categorise|tag` and a consumer's own code do.
+        /** Set a child category, or `null` to clear it. Returns the transaction as Up now holds it. */
+        async setCategory(txId, categoryId, signal) {
+            await send("PATCH", `/transactions/${encodeURIComponent(txId)}/relationships/category`, {
+                data: categoryId === null ? null : { type: "categories", id: categoryId },
+            }, signal);
+            return transaction(txId, signal);
+        },
+        /** Add tags by label (at most 6 per transaction; a duplicate is ignored). Returns the transaction as Up now holds it. */
+        async addTags(txId, labels, signal) {
+            await send("POST", `/transactions/${encodeURIComponent(txId)}/relationships/tags`, tagBody(labels), signal);
+            return transaction(txId, signal);
+        },
+        /** Remove tags by label (an absent one is ignored). Returns the transaction as Up now holds it. */
+        async removeTags(txId, labels, signal) {
+            await send("DELETE", `/transactions/${encodeURIComponent(txId)}/relationships/tags`, tagBody(labels), signal);
+            return transaction(txId, signal);
+        },
+        // Webhooks: reads, then writes behind the same gate.
+        async webhooks(signal) {
+            return (await pages("/webhooks?page[size]=100", WebhookResource, 1000, 10, signal)).items.map(toWebhook);
+        },
+        async webhook(webhookId, signal) {
+            return toWebhook((await get(`/webhooks/${encodeURIComponent(webhookId)}`, One(WebhookResource), signal)).data);
+        },
+        async webhookLogs(webhookId, signal) {
+            const { items } = await pages(`/webhooks/${encodeURIComponent(webhookId)}/logs?page[size]=30`, LogResource, 30, 1, signal);
+            return items.map((l) => ({
+                id: l.id,
+                deliveryStatus: l.attributes?.deliveryStatus,
+                createdAt: l.attributes?.createdAt,
+                statusCode: nul(l.attributes?.response)?.statusCode,
+            }));
+        },
+        /** Create a webhook. Its `secretKey` comes back this once: the caller keeps it; this client never stores or logs it. */
+        async createWebhook(hookUrl, description, signal) {
+            const body = await send("POST", "/webhooks", {
+                data: {
+                    attributes: {
+                        url: hookUrl,
+                        ...(description ? { description } : {}),
+                    },
+                },
+            }, signal);
+            return toWebhook(One(WebhookResource).parse(body).data);
+        },
+        async deleteWebhook(webhookId, signal) {
+            await send("DELETE", `/webhooks/${encodeURIComponent(webhookId)}`, undefined, signal);
+        },
+        /** Ask Up to send a PING event to the webhook. */
+        async pingWebhook(webhookId, signal) {
+            await send("POST", `/webhooks/${encodeURIComponent(webhookId)}/ping`, undefined, signal);
+        },
+    };
+}
+const toWebhook = (w) => ({
+    id: w.id,
+    url: w.attributes?.url,
+    description: nul(w.attributes?.description),
+    createdAt: w.attributes?.createdAt,
+    secretKey: w.attributes?.secretKey,
+});

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

@@ -0,0 +1,91 @@
+import { z } from "zod";
+import { type Clock } from "../../clock.ts";
+import { type Integration } from "../../home.ts";
+import type { Manifest } from "../../manifest.ts";
+import { type Category, type Transaction, type TransactionQuery, type UpClient } from "./client.ts";
+import { type Household, type MerchantSpend, type SpendSummary } from "./spend.ts";
+export { type Account, type Category, type Transaction, type TransactionQuery, type UpClient, upClient, UpError, type Webhook, type WebhookLog, } from "./client.ts";
+export { type CategorySpend, dollars, type Household, inHousehold, isSpend, merchantKey, type MerchantSpend, notSpend, type Recurring, recurring, type SpendSummary, spendByCategory, spendByMerchant, uncategorised, type Unusual, unusual, type Window, } from "./spend.ts";
+export { parseWebhookEvent, SIGNATURE_HEADER, verifyWebhook, type WebhookEvent, } from "./webhook.ts";
+/** Poll every 15 minutes: spending moves slowly, and a webhook can nudge a read sooner. */
+export declare const POLL_MS: number;
+/** Which accounts to read: by type and ownership, never by id (e.g. the joint everyday account). All of them when left out. */
+declare const AccountFilter: z.ZodObject<{
+    accountType: z.ZodOptional<z.ZodEnum<{
+        HOME_LOAN: "HOME_LOAN";
+        SAVER: "SAVER";
+        TRANSACTIONAL: "TRANSACTIONAL";
+    }>>;
+    ownershipType: z.ZodOptional<z.ZodEnum<{
+        INDIVIDUAL: "INDIVIDUAL";
+        JOINT: "JOINT";
+    }>>;
+}, z.core.$strip>;
+export type AccountFilter = z.infer<typeof AccountFilter>;
+/** Up in a home config: the token's env name, and which accounts count as the household's. */
+export declare const configSchema: z.ZodObject<{
+    connector: z.ZodLiteral<"up">;
+    key: z.ZodString;
+    account: z.ZodOptional<z.ZodObject<{
+        accountType: z.ZodOptional<z.ZodEnum<{
+            HOME_LOAN: "HOME_LOAN";
+            SAVER: "SAVER";
+            TRANSACTIONAL: "TRANSACTIONAL";
+        }>>;
+        ownershipType: z.ZodOptional<z.ZodEnum<{
+            INDIVIDUAL: "INDIVIDUAL";
+            JOINT: "JOINT";
+        }>>;
+    }, z.core.$strip>>;
+    household: z.ZodOptional<z.ZodObject<{
+        categories: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+}, z.core.$loose>;
+export type UpConfig = {
+    token: string;
+    account?: AccountFilter;
+    household?: Household;
+    fetch: typeof fetch;
+    clock?: Clock;
+    timeZone?: string;
+};
+/** One month's spend: Up's figures through `spendByCategory`, plus the top merchants. */
+export type MonthSpend = SpendSummary & {
+    month: string;
+    topMerchants: MerchantSpend[];
+};
+/** A transaction as the snapshot keeps it: no raw text, message, note, who spent, account or balance. */
+export type RecentTransaction = Pick<Transaction, "id" | "createdAt" | "description" | "amountCents" | "categoryId" | "parentCategoryId" | "status" | "tags">;
+export type UpSnapshot = {
+    asOf: string;
+    thisMonth: MonthSpend;
+    lastMonth: MonthSpend;
+    uncategorised: string[];
+    recent: RecentTransaction[];
+    accounts: number;
+    household?: Household;
+    truncated: boolean;
+};
+/** Transactions from the accounts a filter names (every account without one), newest first. The one read the integration and `home up` share. */
+export declare function readTransactions(client: UpClient, account: AccountFilter | undefined, query?: TransactionQuery, signal?: AbortSignal): Promise<{
+    transactions: Transaction[];
+    truncated: boolean;
+    accounts: number;
+}>;
+/** The snapshot from two months of transactions: pure, so tests and a consumer's own reads build the same thing. */
+export declare function toSnapshot(txs: Transaction[], categories: Category[], at: {
+    now: number;
+    asOf: string;
+    timeZone?: string;
+    accounts: number;
+    truncated: boolean;
+    household?: Household;
+}): UpSnapshot;
+/** Up as a home integration: two months of transactions now, then every 15 minutes. Reads only; it never writes. */
+export declare function up(config: UpConfig): Integration<UpSnapshot, "up">;
+/** "Oct so far $2,140 · Sep $1,980 · 3 to categorise": this month's spend against last month's. */
+export declare function upText(s: UpSnapshot): string;
+/** One line per parent category this month, largest five: "home $1,030: groceries $620, utilities $410". */
+export declare const categoryLines: (m: MonthSpend) => string[];
+export declare const manifest: Manifest<UpSnapshot>;