@flickfyi/flkr 0.0.141 → 0.0.153

package/node_modules/@flickfyi/core/dist/kowalski/catalog.js

@@ -0,0 +1,639 @@
+import e from "validator/lib/isURL.js";
+import { z as t } from "zod/v4";
+//#region src/kowalski/catalog.ts
+var n = t.string().regex(/^[A-Za-z][A-Za-z0-9]*$/).optional(), r = t.enum(["private", "public"]).default("private"), i = {
+	budget: "spent_",
+	checklist: "completed_",
+	habit: "completed_",
+	poll: "vote_",
+	recipe: "step_",
+	scoreboard: "score_",
+	shoppingList: "got_",
+	taskBoard: "status_"
+}, a = [
+	"sunday",
+	"monday",
+	"tuesday",
+	"wednesday",
+	"thursday",
+	"friday",
+	"saturday"
+], o = {
+	billSplit: {
+		description: "Split a bill equally with an optional tip, rounding in the selected currency.",
+		exportName: "BillSplit",
+		props: d({
+			currency: f(),
+			people: t.number().int().min(1).max(1e3),
+			tipPercent: t.number().min(0).max(100).default(0),
+			title: v("Split the bill"),
+			total: t.number().min(0).max(0xe8d4a51000)
+		}),
+		storeSchema: _({
+			people: t.number().int().min(1).max(1e3).default(1),
+			tipPercent: t.number().min(0).max(100).default(0),
+			total: t.number().min(0).max(0xe8d4a51000).default(0)
+		})
+	},
+	bookmark: {
+		description: "Display, edit, and retain a web bookmark. No implicit metadata fetch.",
+		exportName: "Bookmark",
+		props: d({
+			note: t.string().max(1e4).default(""),
+			title: v(),
+			url: C()
+		}),
+		storeSchema: _({
+			note: w(t.string().max(1e4).default("")),
+			title: w(t.string().max(160).default("")),
+			url: w(C().nullable().default(null))
+		})
+	},
+	budget: {
+		description: "Track spending against category limits for one budget period. No bank connection or payments.",
+		exportName: "Budget",
+		props: d({
+			categories: m({
+				label: t.string().min(1).max(80),
+				limit: t.number().positive().max(0xe8d4a51000)
+			}, 12),
+			currency: f(),
+			title: v("Budget")
+		}),
+		storeSchema: p(i.budget, t.number().min(0).max(0xe8d4a51000), {})
+	},
+	calculator: {
+		description: "A persistent keypad calculator with chained arithmetic, decimals, sign, percent, and repeated equals. Supports +, -, *, /. No executable expression strings.",
+		exportName: "Calculator",
+		props: d({
+			left: t.number().default(0),
+			operator: t.enum([
+				"+",
+				"-",
+				"*",
+				"/"
+			]).default("+"),
+			right: t.number().default(0),
+			title: v("Calculate")
+		}),
+		storeSchema: _({ calculation: t.object({
+			entry: t.string().max(40).regex(/^(?:-?\d+(?:\.\d*)?(?:e[+-]?\d+)?|Error)$/),
+			left: t.number(),
+			operator: t.enum([
+				"+",
+				"-",
+				"*",
+				"/"
+			]),
+			overwrite: t.boolean(),
+			phase: t.enum([
+				"left",
+				"operator",
+				"right",
+				"result",
+				"error"
+			]),
+			right: t.number()
+		}).refine((e) => e.phase === "error" ? e.entry === "Error" : e.entry !== "Error" && Number.isFinite(Number(e.entry)), "Calculator entry must match its phase and represent a finite number.").default({
+			entry: "0",
+			left: 0,
+			operator: "+",
+			overwrite: !1,
+			phase: "left",
+			right: 0
+		}) })
+	},
+	checklist: {
+		description: "A persistent checklist with independent completion and progress. No external actions.",
+		exportName: "Checklist",
+		props: d({
+			items: m({ label: t.string().min(1).max(500) }, 100),
+			title: v()
+		}),
+		storeSchema: p(i.checklist, t.boolean(), {})
+	},
+	colorPalette: {
+		description: "Choose and retain an sRGB color and display matching shades.",
+		exportName: "ColorPalette",
+		props: d({
+			color: t.string().regex(/^#[\da-fA-F]{6}$/),
+			title: v("Palette")
+		}),
+		storeSchema: _({ color: w(t.string().regex(/^#[\da-fA-F]{6}$/).default("#6366f1")) })
+	},
+	contact: {
+		description: "Display, edit, and retain a contact. Does not insert into the address book.",
+		exportName: "Contact",
+		props: d({
+			email: t.email().optional(),
+			name: t.string().min(1).max(160),
+			phone: t.string().min(1).max(80).optional()
+		}),
+		storeSchema: _({
+			email: w(t.email().nullable().default(null)),
+			name: w(t.string().max(160).default("")),
+			phone: w(t.string().min(1).max(80).nullable().default(null))
+		})
+	},
+	countdown: {
+		description: "Count down to an explicit instant. Resolve missing dates before instantiation.",
+		exportName: "Countdown",
+		props: d({
+			target: t.iso.datetime({ offset: !0 }),
+			timeZone: x().default("UTC"),
+			title: v()
+		}),
+		storeSchema: _({ target: w(t.iso.datetime({ offset: !0 }).nullable().default(null)) })
+	},
+	event: {
+		description: "Save and edit event details in the app. Does not create a calendar event.",
+		exportName: "Event",
+		props: d({
+			location: t.string().max(500).default(""),
+			startsAt: t.iso.datetime({ offset: !0 }).nullable().default(null),
+			timeZone: x().default("UTC"),
+			title: v()
+		}),
+		storeSchema: _({
+			location: w(t.string().max(500).default("")),
+			startsAt: w(t.iso.datetime({ offset: !0 }).nullable().default(null)),
+			title: w(t.string().max(160).default(""))
+		})
+	},
+	expense: {
+		description: "Edit and retain one expense. No payments, bank connection, or exchange-rate lookup.",
+		exportName: "Expense",
+		props: d({
+			amount: t.number().min(0).max(0xe8d4a51000),
+			category: t.string().max(80).default("Other"),
+			currency: f(),
+			title: v()
+		}),
+		storeSchema: _({
+			amount: t.number().min(0).max(0xe8d4a51000).default(0),
+			category: w(t.string().max(80).default("Other")),
+			title: w(t.string().max(160).default(""))
+		})
+	},
+	goal: {
+		description: "A personal goal with editable progress, target, and a fixed increment. Not a distributed counter.",
+		exportName: "Goal",
+		props: d({
+			progress: t.number().min(0).max(0xe8d4a51000).default(0),
+			step: t.number().positive().max(1e9).default(1),
+			target: t.number().positive().max(0xe8d4a51000),
+			title: v(),
+			unit: t.string().max(40).default("")
+		}),
+		storeSchema: _({ progress: t.number().min(0).default(0) })
+	},
+	habit: {
+		description: "Track a habit by local date and edit its weekday schedule. No notifications.",
+		exportName: "Habit",
+		props: d({
+			timeZone: x().default("UTC"),
+			title: v(),
+			weekdays: S()
+		}),
+		storeSchema: p(i.habit, t.boolean(), { weekdays: S() })
+	},
+	ledger: {
+		description: "A running tab of shared costs between two people, split evenly, with settle up. No payments.",
+		exportName: "Ledger",
+		props: d({
+			currency: f(),
+			people: m({ label: t.string().min(1).max(80) }, 2, 2),
+			title: v("Shared tab")
+		}),
+		storeSchema: _({ entries: t.array(t.strictObject({
+			amount: t.number().positive().max(0xe8d4a51000),
+			id: h(),
+			label: t.string().max(160),
+			paidBy: h()
+		})).max(200).default([]) })
+	},
+	note: {
+		description: "An editable persistent note. Plain text; no HTML or code execution.",
+		exportName: "Note",
+		props: d({
+			body: t.string().max(2e4),
+			title: t.string().max(160)
+		}),
+		storeSchema: _({
+			body: w(t.string().max(2e4).default("")),
+			title: w(t.string().max(160).default(""))
+		})
+	},
+	poll: {
+		exportName: "Poll",
+		description: "Cast or change a vote and derive totals from votes. Shared voting only when explicitly requested.",
+		props: d({
+			options: m({ label: t.string().min(1).max(160) }, 12, 2),
+			question: t.string().min(1).max(500),
+			shared: t.boolean().default(!1)
+		}),
+		storeSchema: p(i.poll, h(), {})
+	},
+	randomPicker: {
+		description: "Flip a coin, roll a die, or pick from a bounded integer range or list. Retains the last result.",
+		exportName: "RandomPicker",
+		props: t.discriminatedUnion("mode", [
+			d({
+				mode: t.literal("coin"),
+				title: v("Pick one")
+			}),
+			d({
+				mode: t.literal("dice"),
+				title: v("Pick one")
+			}),
+			d({
+				maximum: t.number().int().min(-1e9).max(1e9),
+				minimum: t.number().int().min(-1e9).max(1e9),
+				mode: t.literal("range"),
+				title: v("Pick one")
+			}).refine((e) => e.minimum <= e.maximum, {
+				message: "Minimum cannot exceed maximum.",
+				path: ["maximum"]
+			}),
+			d({
+				mode: t.literal("list"),
+				options: t.array(t.string().min(1).max(160)).min(1).max(100),
+				title: v("Pick one")
+			})
+		]),
+		storeSchema: _({ result: t.strictObject({
+			domain: g(),
+			value: t.union([t.number().int(), t.string().max(160)])
+		}).nullable().default(null) })
+	},
+	rating: {
+		description: "Rate one thing from one to five stars and keep a short note about it.",
+		exportName: "Rating",
+		props: d({
+			subject: t.string().min(1).max(160),
+			title: v("Your rating")
+		}),
+		storeSchema: _({
+			note: w(t.string().max(2e3).default("")),
+			stars: t.number().int().min(0).max(5).default(0)
+		})
+	},
+	recipe: {
+		description: "Cook a recipe whose steps follow the Recipe Graph Format (rgf/0-draft): each step uses ingredients or earlier step outputs, waits on the steps in after, and may carry a duration, doneness cue, and attention. Ingredients carry a numeric amount and unit, and meta.servings is a number, so amounts scale with servings. Shows running timers, the current step, and the next few. No nutrition or shopping lookup.",
+		exportName: "Recipe",
+		props: d({
+			ingredients: m({
+				amount: t.number().positive().max(1e6).optional(),
+				label: t.string().min(1).max(160),
+				notes: t.array(t.string().max(160)).max(10).optional(),
+				unit: t.string().max(40).optional()
+			}, 60),
+			servings: t.number().int().min(1).max(100).optional(),
+			steps: t.array(t.strictObject({
+				after: t.array(h()).max(60).optional(),
+				attention: t.enum(["active", "passive"]).optional(),
+				doneness: t.string().max(200).optional(),
+				duration: t.strictObject({
+					maxMinutes: t.number().nonnegative().max(10080).optional(),
+					minMinutes: t.number().nonnegative().max(10080).optional(),
+					raw: t.string().min(1).max(80)
+				}).refine((e) => e.minMinutes === void 0 || e.maxMinutes === void 0 || e.minMinutes <= e.maxMinutes, "minMinutes cannot exceed maxMinutes.").optional(),
+				equipment: t.array(t.string().min(1).max(160)).max(20).optional(),
+				id: h(),
+				instruction: t.string().min(1).max(500),
+				kind: t.enum([
+					"setup",
+					"transform",
+					"wait",
+					"serve"
+				]).optional(),
+				label: t.string().max(80).optional(),
+				outputs: t.array(t.strictObject({
+					id: h(),
+					name: t.string().max(160).optional()
+				})).max(10).optional(),
+				temperature: t.string().min(1).max(80).optional(),
+				uses: t.array(t.strictObject({
+					id: h(),
+					portion: t.string().max(80).optional(),
+					source: t.discriminatedUnion("kind", [t.strictObject({
+						ingredientId: h(),
+						kind: t.literal("ingredient")
+					}), t.strictObject({
+						kind: t.literal("output"),
+						outputId: h()
+					})])
+				})).max(30).default([])
+			})).min(1).max(60),
+			title: v(),
+			yield: t.string().max(160).optional()
+		}).superRefine((e, t) => {
+			let n = new Set(e.ingredients.map((e) => e.id)), r = /* @__PURE__ */ new Set(), i = /* @__PURE__ */ new Set();
+			for (let a of e.steps) {
+				!r.has(a.id) && (a.after ?? []).every((e) => r.has(e)) && a.uses.every((e) => e.source.kind === "ingredient" ? n.has(e.source.ingredientId) : i.has(e.source.outputId)) || t.addIssue({
+					code: "custom",
+					message: `Step ${a.id} needs a unique ID and can only use ingredients and earlier steps.`
+				}), r.add(a.id);
+				for (let e of a.outputs ?? []) i.has(e.id) && t.addIssue({
+					code: "custom",
+					message: "Output IDs must be unique."
+				}), i.add(e.id);
+			}
+		}),
+		storeSchema: p(i.recipe, t.strictObject({
+			done: t.boolean(),
+			endsAt: t.number().nullable()
+		}), {
+			cooking: t.boolean().default(!1),
+			servings: t.number().int().min(1).max(100).default(1)
+		})
+	},
+	reminder: {
+		description: "Complete, reopen, and edit an in-app reminder. Does not schedule notifications.",
+		exportName: "Reminder",
+		props: d({
+			dueAt: t.iso.datetime({ offset: !0 }).nullable().default(null),
+			recurrence: t.enum([
+				"none",
+				"daily",
+				"weekly"
+			]).default("none"),
+			timeZone: x().optional(),
+			title: t.string().min(1).max(500)
+		}),
+		storeSchema: _({
+			completedAt: t.number().nullable().default(null),
+			dueAt: w(t.iso.datetime({ offset: !0 }).nullable().default(null)),
+			title: w(t.string().max(500).default(""))
+		})
+	},
+	rotation: {
+		description: "Take turns through a fixed group in order and pass the turn on when done.",
+		exportName: "Rotation",
+		props: d({
+			people: m({ label: t.string().min(1).max(80) }, 20, 2),
+			task: t.string().min(1).max(160),
+			title: v("Whose turn")
+		}),
+		storeSchema: _({
+			completed: t.number().int().min(0).default(0),
+			turn: h().nullable().default(null)
+		})
+	},
+	scoreboard: {
+		description: "Keep score for a few players with a fixed step. Not a distributed counter or a league.",
+		exportName: "Scoreboard",
+		props: d({
+			players: m({ label: t.string().min(1).max(80) }, 12, 2),
+			step: t.number().int().positive().max(1e3).default(1),
+			title: v("Scores")
+		}),
+		storeSchema: p(i.scoreboard, t.number().int(), {})
+	},
+	shoppingList: {
+		description: "Check items off a shopping list with optional prices and a running cart total. No ordering.",
+		exportName: "ShoppingList",
+		props: d({
+			currency: f(),
+			items: m({
+				label: t.string().min(1).max(160),
+				price: t.number().min(0).max(1e9).optional(),
+				quantity: t.number().int().min(1).max(999).default(1)
+			}, 100),
+			title: v("Shopping list")
+		}),
+		storeSchema: p(i.shoppingList, t.boolean(), {})
+	},
+	taskBoard: {
+		description: "Move tasks between To do, Doing, and Done. No assignees, dates, or sync.",
+		exportName: "TaskBoard",
+		props: d({
+			tasks: m({ label: t.string().min(1).max(500) }, 50),
+			title: v("Tasks")
+		}),
+		storeSchema: p(i.taskBoard, t.enum([
+			"todo",
+			"doing",
+			"done"
+		]), {})
+	},
+	timeZone: {
+		description: "Compare local times in named time zones, live or at an explicit instant.",
+		exportName: "TimeZone",
+		props: d({
+			at: t.iso.datetime({ offset: !0 }).nullable().default(null),
+			title: v("World clock"),
+			zones: t.array(x()).min(2).max(6)
+		}),
+		storeSchema: _({ at: w(t.iso.datetime({ offset: !0 }).nullable().default(null)) })
+	},
+	timer: {
+		description: "Countdown, focus, break, or stopwatch. Start, pause, resume, reset; no background alarm.",
+		exportName: "Timer",
+		props: d({
+			durationSeconds: t.number().int().min(1).max(604800).default(300),
+			mode: t.enum([
+				"countdown",
+				"focus",
+				"break",
+				"stopwatch"
+			]).default("countdown"),
+			title: v("Timer")
+		}),
+		storeSchema: _({
+			elapsedSeconds: t.number().min(0).default(0),
+			startedAt: t.number().nullable().default(null)
+		})
+	},
+	trip: {
+		description: "Edit and retain trip details. No bookings or itinerary retrieval.",
+		exportName: "Trip",
+		props: d({
+			destination: t.string().min(1).max(160),
+			endDate: t.iso.date().nullable().default(null),
+			origin: t.string().min(1).max(160),
+			startDate: t.iso.date().nullable().default(null),
+			title: v("Trip"),
+			transport: t.enum([
+				"car",
+				"train",
+				"plane",
+				"walk",
+				"other"
+			]).default("other")
+		}).refine((e) => !e.startDate || !e.endDate || e.endDate >= e.startDate, {
+			message: "The trip cannot end before it starts.",
+			path: ["endDate"]
+		}),
+		storeSchema: _({
+			destination: w(t.string().max(160).default("")),
+			endDate: w(t.iso.date().nullable().default(null)),
+			origin: w(t.string().max(160).default("")),
+			startDate: w(t.iso.date().nullable().default(null))
+		}).refine((e) => !e.startDate.value || !e.endDate.value || e.endDate.value >= e.startDate.value, "The trip cannot end before it starts.")
+	},
+	unitConverter: {
+		description: "Convert compatible length, mass, or temperature units deterministically.",
+		exportName: "UnitConverter",
+		props: d({
+			from: b(),
+			title: v("Convert"),
+			to: b(),
+			value: t.number()
+		}).refine(({ from: e, to: t }) => u[e].dimension === u[t].dimension, {
+			message: "Source and destination units must measure the same dimension.",
+			path: ["to"]
+		}),
+		storeSchema: _({
+			from: w(b().default("km")),
+			to: w(b().default("mi")),
+			value: t.number().default(0)
+		}).refine(({ from: e, to: t }) => u[e.value].dimension === u[t.value].dimension, "Incompatible units.")
+	}
+}, s = t.enum(/* @__PURE__ */ "checklist.timer.habit.goal.poll.event.reminder.trip.countdown.timeZone.colorPalette.billSplit.expense.unitConverter.calculator.randomPicker.contact.bookmark.note.budget.scoreboard.taskBoard.recipe.rotation.shoppingList.rating.ledger".split(".")), c = t.object({
+	configuration: t.string().default(""),
+	voter: t.string().min(1)
+}), l = {
+	max_allowed_length: 2048,
+	protocols: ["http", "https"],
+	require_host: !0,
+	require_protocol: !0,
+	require_tld: !1,
+	require_valid_protocol: !0
+}, u = {
+	c: {
+		dimension: "temperature",
+		factor: 1,
+		offset: 0
+	},
+	f: {
+		dimension: "temperature",
+		factor: 5 / 9,
+		offset: -32
+	},
+	ft: {
+		dimension: "length",
+		factor: .3048,
+		offset: 0
+	},
+	g: {
+		dimension: "mass",
+		factor: .001,
+		offset: 0
+	},
+	k: {
+		dimension: "temperature",
+		factor: 1,
+		offset: -273.15
+	},
+	kg: {
+		dimension: "mass",
+		factor: 1,
+		offset: 0
+	},
+	km: {
+		dimension: "length",
+		factor: 1e3,
+		offset: 0
+	},
+	lb: {
+		dimension: "mass",
+		factor: .45359237,
+		offset: 0
+	},
+	m: {
+		dimension: "length",
+		factor: 1,
+		offset: 0
+	},
+	mi: {
+		dimension: "length",
+		factor: 1609.344,
+		offset: 0
+	}
+};
+function d(e) {
+	return t.strictObject({
+		id: n,
+		revision: t.number().int().min(0).default(0),
+		scope: r,
+		...e
+	});
+}
+function f() {
+	return t.string().regex(/^[A-Z]{3}$/).default("USD");
+}
+function p(e, n, r) {
+	let i = _(r), a = new Set(Object.keys(i.shape));
+	return t.intersection(i.loose(), t.looseRecord(t.templateLiteral([e, t.string()]), n)).refine((t) => Object.keys(t).every((t) => a.has(t) || t.startsWith(e)), `Item fields must start with ${e}.`);
+}
+function m(e, n, r = 1) {
+	return t.array(t.strictObject(e).extend({ id: h() })).min(r).max(n).refine(y, "IDs must be unique.");
+}
+function h() {
+	return t.string().min(1).max(80).refine((e) => e !== "__proto__");
+}
+function g() {
+	return t.union([
+		t.strictObject({ mode: t.literal("coin") }),
+		t.strictObject({ mode: t.literal("dice") }),
+		t.strictObject({
+			maximum: t.number().int(),
+			minimum: t.number().int(),
+			mode: t.literal("range")
+		}),
+		t.strictObject({
+			mode: t.literal("list"),
+			options: t.array(t.string().max(160)).max(100)
+		})
+	]);
+}
+function _(e) {
+	return t.object({
+		configuration: t.record(t.string(), t.unknown()).nullable().default(null),
+		configurationRevision: t.number().int().min(0).default(0),
+		...e
+	});
+}
+function v(e) {
+	let n = t.string().min(1).max(160);
+	return e === void 0 ? n : n.default(e);
+}
+function y(e) {
+	let t = e.map((e) => "id" in e ? e.id : void 0);
+	return new Set(t).size === t.length;
+}
+function b() {
+	return t.enum([
+		"m",
+		"km",
+		"mi",
+		"ft",
+		"kg",
+		"g",
+		"lb",
+		"c",
+		"f",
+		"k"
+	]);
+}
+function x() {
+	return t.string().max(80).refine((e) => {
+		try {
+			return new Intl.DateTimeFormat("en", { timeZone: e }).format(0), !0;
+		} catch {
+			return !1;
+		}
+	}, "Use a valid IANA time zone.");
+}
+function S() {
+	return t.array(t.enum(a)).max(7).default([...a]);
+}
+function C() {
+	return t.string().max(2048).refine((t) => e(t, l), "Use a valid HTTP or HTTPS address.");
+}
+function w(e) {
+	return t.object({ value: e }).default(() => ({ value: e.parse(void 0) }));
+}
+//#endregion
+export { i as entryPrefixes, o as kowalskiCatalog, s as kowalskiComponentSchema, n as kowalskiFeatureId, r as kowalskiScope, c as pollVoterSchema, u as unitDefinitions, l as webAddressOptions, a as weekdayNames };

package/node_modules/@flickfyi/core/dist/kowalski/clocks.d.ts

@@ -0,0 +1,4 @@
+import { KowalskiInput } from './catalog.js';
+export declare function Timer(input: KowalskiInput<'timer'>): import("@flickfyi/photon/jsx-runtime").JSX.Element;
+export declare function Countdown(input: KowalskiInput<'countdown'>): import("@flickfyi/photon/jsx-runtime").JSX.Element;
+export declare function TimeZone(input: KowalskiInput<'timeZone'>): import("@flickfyi/photon/jsx-runtime").JSX.Element;

package/node_modules/@flickfyi/core/dist/kowalski/date-time.d.ts

@@ -0,0 +1,22 @@
+import { KowalskiComponent } from './catalog.js';
+/** Stores an instant and edits calendar time in the supplied IANA timezone. */
+export declare function FeatureDateTime(props: DateEditorProps & {
+    timeZone: string;
+}): import("@flickfyi/photon/jsx-runtime").JSX.Element;
+/** Date-only values remain calendar dates, without device timezone conversion. */
+export declare function FeatureDate(props: DateEditorProps): import("@flickfyi/photon/jsx-runtime").JSX.Element;
+type DateEditorProps = {
+    actionLabel?: string;
+    clearable?: boolean;
+    compact?: boolean;
+    component: KowalskiComponent;
+    label: string;
+    inline?: boolean;
+    onChange: (value: string | null, onSaved?: () => void) => boolean | void;
+    onEditingChange?: (editing: boolean) => void;
+    ready: boolean;
+    saving?: boolean;
+    submitLabel?: string;
+    value: string | null;
+};
+export {};

package/node_modules/@flickfyi/core/dist/kowalski/details.d.ts

@@ -0,0 +1,7 @@
+import { KowalskiInput } from './catalog.js';
+export declare function Event(input: KowalskiInput<'event'>): import("@flickfyi/photon/jsx-runtime").JSX.Element;
+export declare function Reminder(input: KowalskiInput<'reminder'>): import("@flickfyi/photon/jsx-runtime").JSX.Element;
+export declare function Trip(input: KowalskiInput<'trip'>): import("@flickfyi/photon/jsx-runtime").JSX.Element;
+export declare function Contact(input: KowalskiInput<'contact'>): import("@flickfyi/photon/jsx-runtime").JSX.Element;
+export declare function Bookmark(input: KowalskiInput<'bookmark'>): import("@flickfyi/photon/jsx-runtime").JSX.Element;
+export declare function Note(input: KowalskiInput<'note'>): import("@flickfyi/photon/jsx-runtime").JSX.Element;

package/node_modules/@flickfyi/core/dist/kowalski/everyday.d.ts

@@ -0,0 +1,8 @@
+import { KowalskiInput } from './catalog.js';
+export declare function Budget(input: KowalskiInput<'budget'>): import("@flickfyi/photon/jsx-runtime").JSX.Element;
+export declare function Scoreboard(input: KowalskiInput<'scoreboard'>): import("@flickfyi/photon/jsx-runtime").JSX.Element;
+export declare function TaskBoard(input: KowalskiInput<'taskBoard'>): import("@flickfyi/photon/jsx-runtime").JSX.Element;
+export declare function Rotation(input: KowalskiInput<'rotation'>): import("@flickfyi/photon/jsx-runtime").JSX.Element;
+export declare function ShoppingList(input: KowalskiInput<'shoppingList'>): import("@flickfyi/photon/jsx-runtime").JSX.Element;
+export declare function Rating(input: KowalskiInput<'rating'>): import("@flickfyi/photon/jsx-runtime").JSX.Element;
+export declare function Ledger(input: KowalskiInput<'ledger'>): import("@flickfyi/photon/jsx-runtime").JSX.Element;

package/node_modules/@flickfyi/core/dist/kowalski/format.d.ts

@@ -0,0 +1,4 @@
+/** Kowalski's authored English UI uses one cache for display and editor formatting. */
+export declare const format: import('@formatjs/intl').IntlShape<string>;
+/** Validate the UI's English decimal/currency grammar before removing its fixed affixes. */
+export declare function parseNumberInput(text: string, currency?: string): number;