@ham2k/extension-sdk 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,1361 @@
+// @ham2k/extension-sdk 0.1.0
+export type CallInfo = {
+	call: string;
+	baseCall?: string;
+	prefix?: string;
+	prefixOverride?: string;
+	ituPrefix?: string;
+	digit?: string;
+	preindicator?: string;
+	postindicators?: string[];
+	indicators?: string[];
+	entityPrefix?: string;
+	entityName?: string;
+	dxccCode?: number;
+	continent?: string;
+	cqZone?: number;
+	ituZone?: number;
+	regionCode?: string;
+	tz?: string;
+	matchSource?: string;
+	matchNote?: string;
+	location?: String;
+	lat?: number;
+	lon?: number;
+	grid?: string;
+	locSource?: string;
+	locationScope?: "qth" | "prefixed" | "portable";
+	name?: string;
+	city?: string;
+	state?: string;
+	county?: string;
+	country?: string;
+	exchange?: string;
+	sent?: string;
+};
+export type CallInfoLookup = CallInfo & {
+	source?: String;
+	scope?: "general" | "operation" | "qso";
+	notes?: String[];
+	history?: QSON[];
+};
+export type AnnotatedCallInfo = CallInfo & {
+	guess?: CallInfo;
+	lookups?: CallInfoLookup[];
+};
+export type RefInfo = {
+	type: string;
+	ref?: string;
+	label?: string;
+};
+export type QSLInfo = {
+	type: string;
+	ref?: string;
+	label?: string;
+	received?: boolean;
+};
+export type EventInfo = {
+	event: string;
+	operation?: Operation;
+};
+export type QSON = {
+	uuid?: string;
+	event?: EventInfo;
+	our: AnnotatedCallInfo;
+	their: AnnotatedCallInfo;
+	freq: number;
+	band: string;
+	mode: string;
+	startAt?: string;
+	startAtMillis?: number;
+	endAt?: string;
+	endAtMillis?: number;
+	number?: number;
+	line?: number;
+	deleted?: boolean;
+	refs?: RefInfo[];
+	qsl?: QSLInfo[];
+};
+export type Operation = {
+	uuid?: string;
+	deleted?: boolean;
+	stationCall?: string;
+	stationCallPlus?: string;
+	operatorCall?: string;
+	grid?: string;
+	qsoCount?: number;
+	title?: string;
+	qsos?: QSON[];
+	refs?: RefInfo[];
+};
+export type JSONValue = string | number | boolean | null | JSONValue[] | {
+	[key: string]: JSONValue;
+};
+export interface HookContext {
+	online: boolean;
+	account?: {
+		credentials?: Record<string, string>;
+		session?: Record<string, string>;
+	};
+	developerMode?: boolean;
+	locale?: string;
+	appName?: string;
+	distanceUnits?: string;
+	decimalSeparator?: string;
+	groupingSeparator?: string;
+	edition?: string;
+	enabledExperiments?: string[];
+	getOperation?(uuid: string): Promise<Record<string, JSONValue> | null>;
+	getQsos?(operationUuid: string): Promise<Record<string, JSONValue>[] | null>;
+	getSpotsForCall?(call: string, maxAgeMinutes?: number): Promise<Spot[]>;
+	getHistoryForCall?(call: string): Promise<Record<string, JSONValue>[]>;
+}
+export type LookupResult = (CallInfoLookup & {
+	locAccuracy?: number;
+	refs?: RefInfo[];
+	online?: boolean;
+})[];
+export interface LookupHook {
+	lookupCall(args: {
+		callInfo: AnnotatedCallInfo;
+		qso: Record<string, JSONValue>;
+		operation: Record<string, JSONValue>;
+	}, ctx: HookContext): Promise<LookupResult>;
+}
+export type RecentContextLookupHook = LookupHook;
+export interface LookupServiceRequest {
+	callInfo: CallInfo;
+	qso: Record<string, JSONValue>;
+	operation: Record<string, JSONValue>;
+	recentContext?: boolean;
+}
+export interface LookupServiceResult {
+	lookups: CallInfoLookup[];
+	guess: CallInfo;
+}
+export interface LookupServiceHook {
+	lookupCallInfo(args: LookupServiceRequest, ctx: HookContext): Promise<LookupServiceResult>;
+}
+export interface SpotRef {
+	type: string;
+	ref: string;
+}
+export interface Spot {
+	their: {
+		call: string;
+	};
+	freq?: number;
+	band?: string;
+	mode?: string;
+	refs?: SpotRef[];
+	icon?: string;
+	spot: {
+		timeInMillis: number;
+		source: string;
+		label?: string;
+		sourceInfo?: Record<string, JSONValue>;
+	};
+}
+export interface SpotEligibility {
+	enabled: boolean;
+	icon?: string;
+}
+export interface PostResult {
+	ok: boolean;
+	message?: string;
+	userMessage?: ResultMessage;
+}
+export interface ResultMessage {
+	presentation: "status" | "dialog";
+	title?: string;
+	text: string;
+	icon?: string;
+	actions?: NoticeAction[];
+}
+export interface PostSelfSpotRequest {
+	operation: Record<string, JSONValue>;
+	freq: number;
+	mode?: string;
+	comment?: string;
+}
+export interface PostOtherSpotRequest {
+	qso: Record<string, JSONValue>;
+	comment?: string;
+	spotterCall?: string;
+}
+export interface SpotsHook {
+	sourceName: string;
+	fetchSpots(args: Record<string, never>, ctx: HookContext): Promise<Spot[]>;
+	isSelfSpotEnabled?(args: {
+		operation: Record<string, JSONValue>;
+	}, ctx: HookContext): Promise<SpotEligibility>;
+	isOtherSpotEnabled?(args: {
+		qso: Record<string, JSONValue>;
+	}, ctx: HookContext): Promise<SpotEligibility>;
+	postSelfSpot?(args: PostSelfSpotRequest, ctx: HookContext): Promise<PostResult>;
+	postOtherSpot?(args: PostOtherSpotRequest, ctx: HookContext): Promise<PostResult>;
+}
+export interface Ref {
+	type: string;
+	ref?: string;
+	name?: string;
+	label?: string;
+	shortLabel?: string;
+	grid?: string;
+	lat?: number;
+	lon?: number;
+	location?: string;
+	program?: string;
+	retired?: boolean;
+	for?: "operation" | "qso";
+	[key: string]: JSONValue | undefined;
+}
+export interface TitleSuggestion {
+	title?: string;
+	for?: string;
+	at?: string;
+	subtitle?: string;
+	priority?: number;
+}
+export interface RefLink {
+	url: string;
+	label?: string;
+}
+export interface RefHandlerHook {
+	validateRef?(args: {
+		ref: Ref;
+	}, ctx: HookContext): Promise<{
+		valid: boolean;
+		normalized?: string;
+	}>;
+	decorateRef?(args: {
+		ref: Ref;
+	}, ctx: HookContext): Promise<Ref>;
+	suggestOperationTitle?(args: {
+		ref: Ref;
+		operation: Record<string, JSONValue>;
+	}, ctx: HookContext): Promise<TitleSuggestion | null>;
+	linkForRef?(args: {
+		ref: Ref;
+	}, ctx: HookContext): Promise<RefLink | null>;
+	geojsonUrlForRef?(args: {
+		ref: Ref;
+	}, ctx: HookContext): Promise<RefGeojson | null>;
+}
+export interface RefGeojson {
+	url: string;
+	maxAgeInDays?: number;
+	missMaxAgeInDays?: number;
+}
+export interface LoggingControlDescriptor {
+	key: string;
+	label: string;
+	icon?: string;
+	color?: string;
+	order?: number;
+	optionType?: "optional" | "mandatory";
+	editable?: boolean;
+	allowsMultiple?: boolean;
+	input: InputDescriptor;
+}
+export type InputDescriptor = RefListInputDescriptor | TextInputDescriptor | OptionsInputDescriptor | SerialInputDescriptor | FormInputDescriptor;
+export interface SequenceBinding {
+	key: string;
+	scope?: ("band" | "mode")[];
+	start?: number;
+	padTo?: number;
+}
+export interface SerialInputDescriptor {
+	kind: "serial";
+	refType: string;
+	field: string;
+	sequence: SequenceBinding;
+	editable?: boolean;
+}
+export interface FormInputDescriptor {
+	kind: "form";
+	refType: string;
+	form: FormDefinition;
+}
+export interface TextInputDescriptor {
+	kind: "text";
+	refType: string;
+	field: string;
+	placeholder?: string;
+	pattern?: string;
+	transforms?: {
+		pattern: string;
+		replacement: string;
+		flags?: string;
+	}[];
+	numeric?: boolean;
+	uppercase?: boolean;
+	maxLength?: number;
+	suggestedValue?: string;
+}
+export interface OptionsInputDescriptor {
+	kind: "options";
+	refType: string;
+	field: string;
+	options: {
+		code: string;
+		name?: string;
+	}[];
+	matchOn?: ("code" | "name")[];
+	allowFreeform?: boolean;
+	preferredCodes?: string[];
+	minCharsForSuggestions?: number;
+	placeholder?: string;
+	uppercase?: boolean;
+	maxLength?: number;
+	suggestedValue?: string;
+	pattern?: string;
+	transforms?: {
+		pattern: string;
+		replacement: string;
+		flags?: string;
+	}[];
+	numeric?: boolean;
+}
+export interface RefListInputDescriptor {
+	kind: "refList";
+	refType: string;
+	placeholder?: string;
+	pattern?: string;
+	transforms?: {
+		pattern: string;
+		replacement: string;
+		flags?: string;
+	}[];
+}
+export interface ActivitySuggestion extends Ref {
+	distance?: number;
+	relevance?: number;
+	allowsMultiple?: boolean;
+}
+export interface SuggestArgs {
+	operation: Record<string, JSONValue>;
+	location?: {
+		lat: number;
+		lon: number;
+	};
+	callsign?: string;
+	searchTerm?: string;
+	scoped?: boolean;
+}
+export interface ActivityHook {
+	loggingControls?(args: {
+		operation: Record<string, JSONValue>;
+		qso?: Record<string, JSONValue>;
+	}, ctx: HookContext): Promise<LoggingControlDescriptor[]>;
+	operationControls?(args: {
+		operation: Record<string, JSONValue>;
+		qso?: Record<string, JSONValue>;
+	}, ctx: HookContext): Promise<LoggingControlDescriptor[]>;
+	suggest?(args: SuggestArgs, ctx: HookContext): Promise<ActivitySuggestion[]>;
+	processQsoBeforeSave?(args: {
+		qso: Record<string, JSONValue>;
+		operation: Record<string, JSONValue>;
+	}, ctx: HookContext): Promise<Record<string, JSONValue> | null>;
+}
+export interface AdifFieldsHook {
+	fieldsForOneQSO(args: {
+		qso: Record<string, JSONValue>;
+		operation: Record<string, JSONValue>;
+	}, ctx: HookContext): Promise<{
+		name: string;
+		value: string;
+	}[]>;
+}
+export interface AdifImportResult {
+	refs?: Ref[];
+}
+export interface AdifImportHook {
+	refsForRecords(args: {
+		records: {
+			fields: Record<string, string>;
+		}[];
+	}, ctx: HookContext): Promise<(AdifImportResult | null)[]>;
+}
+export interface ExportRequest {
+	operation: Record<string, JSONValue>;
+	qsos: Record<string, JSONValue>[];
+	exportType?: string;
+	compactFilenames?: boolean;
+	includePrivateData?: boolean;
+	mainHandler?: string;
+	includeFieldsFrom?: string[];
+}
+export interface ExportResult {
+	filename: string;
+	mimeType: string;
+	content: string;
+}
+export interface ExportOptionsRequest {
+	operation: Record<string, JSONValue>;
+	qsos: Record<string, JSONValue>[];
+	compactFilenames?: boolean;
+}
+export interface ExportOption {
+	exportType: string;
+	format: string;
+	label: string;
+	filename?: string;
+	icon?: string;
+	color?: string;
+	alwaysIncludePrivateData?: boolean;
+	priority?: number;
+	selectedByDefault?: boolean;
+	refType?: string;
+}
+export interface ExportHook {
+	suggestExportOptions?(args: ExportOptionsRequest, ctx: HookContext): Promise<ExportOption[]>;
+	generateExport(args: ExportRequest, ctx: HookContext): Promise<ExportResult>;
+}
+export interface QsoScoreVerdict {
+	value: number;
+	dupe?: boolean;
+	notices?: string[];
+	alerts?: string[];
+	[extra: string]: JSONValue | undefined;
+}
+export type QsoScoreEntry = Record<string, QsoScoreVerdict>;
+export interface ScoreTally {
+	key: string;
+	for: "day" | "operation";
+	icon?: string;
+	label?: string;
+	summary?: string;
+	longSummary?: string;
+	grid?: boolean;
+	total: number;
+	[extra: string]: JSONValue | undefined;
+}
+export interface DayScoreSummary {
+	day: number;
+	count: number;
+	scores: Record<string, ScoreTally>;
+}
+export interface OperationSegmentPayload {
+	fromMillis: number;
+	operation: Record<string, JSONValue>;
+}
+export interface ScoreQsosRequest {
+	operation: Record<string, JSONValue>;
+	qsos: Record<string, JSONValue>[];
+	segments?: OperationSegmentPayload[];
+	ref?: Record<string, JSONValue>;
+	resumeFrom?: JSONValue;
+}
+export interface ScoreQsosResult {
+	qsoScores: Record<string, QsoScoreVerdict>;
+	daySections: DayScoreSummary[];
+	operationSummary: Record<string, ScoreTally>;
+	scoresheet?: JSONValue;
+}
+export interface ScoreQsoRequest {
+	operation: Record<string, JSONValue>;
+	qso: Record<string, JSONValue>;
+	excludeUuid?: string;
+	ref?: Record<string, JSONValue>;
+	segments?: OperationSegmentPayload[];
+	resumeFrom?: JSONValue;
+}
+export interface QsoScoreNotices {
+	notices: string[];
+	alerts: string[];
+}
+export interface ScoreCandidatesRequest {
+	operation: Record<string, JSONValue>;
+	candidates: {
+		key: string;
+		qso: Record<string, JSONValue>;
+	}[];
+	ref?: Record<string, JSONValue>;
+	segments?: OperationSegmentPayload[];
+	resumeFrom?: JSONValue;
+}
+export type ScoreCandidatesResult = Record<string, QsoScoreNotices>;
+export interface ScoringHook {
+	scoreQsos(args: ScoreQsosRequest, ctx: HookContext): Promise<ScoreQsosResult>;
+	scoreQso?(args: ScoreQsoRequest, ctx: HookContext): Promise<QsoScoreNotices>;
+	scoreCandidates?(args: ScoreCandidatesRequest, ctx: HookContext): Promise<ScoreCandidatesResult>;
+}
+export type ScoringScope = "always" | {
+	refTypes: string[];
+	huntingRefTypes?: string[];
+};
+export type Scoresheet = JSONValue;
+export interface ContestScorer<S extends Scoresheet = Scoresheet> {
+	startScoresheet(args: {
+		operation: Record<string, JSONValue>;
+		ref?: Record<string, JSONValue>;
+	}, ctx: HookContext): S;
+	scoreQso(args: {
+		scoresheet: S;
+		qso: Record<string, JSONValue>;
+		operation: Record<string, JSONValue>;
+		ref?: Record<string, JSONValue>;
+		isNewDay: boolean;
+	}, ctx: HookContext): {
+		scoresheet: S;
+		score: QsoScoreVerdict;
+	};
+	summarizeScore(args: {
+		scoresheet: S;
+		operation: Record<string, JSONValue>;
+		ref?: Record<string, JSONValue>;
+		scope: "day" | "operation";
+	}, ctx: HookContext): Record<string, ScoreTally>;
+}
+export interface CommandAction {
+	setVfo?: {
+		freq?: number;
+		band?: string;
+		mode?: string;
+	};
+	setPower?: {
+		watts: number;
+	};
+	updateQso?: Record<string, JSONValue>;
+	addQso?: Record<string, JSONValue>;
+	sendSpots?: {
+		comment?: string;
+		target?: "self" | "last";
+	};
+	syncAll?: Record<string, never>;
+	purgeTests?: Record<string, never>;
+	updateSettings?: {
+		developerMode?: boolean;
+	};
+	updateSetting?: {
+		key: string;
+		value: JSONValue;
+	};
+	openSettings?: {
+		keys: string[];
+		title?: string;
+	};
+	updateOperation?: {
+		operatorCall?: string;
+		multiIdentifier?: string;
+	};
+	setCallField?: {
+		text: string;
+	};
+	reloadDataFiles?: {
+		target: string;
+	};
+	devNotice?: {
+		key?: string;
+		icon?: string;
+		title?: string;
+		text: string;
+	};
+	devStatus?: {
+		key?: string;
+		icon?: string;
+		title?: string;
+		text?: string;
+	};
+	devProgress?: {
+		icon?: string;
+		title?: string;
+		percent?: number;
+	};
+	devHammer?: {
+		seconds?: number;
+	};
+	devSplash?: Record<string, never>;
+	devOnboard?: Record<string, never>;
+	devTester?: Record<string, never>;
+	devPopup?: Record<string, never>;
+	devTimeTravel?: {
+		reset?: boolean;
+		deltaMillis?: number;
+		speed?: number;
+	};
+	toggleExperiment?: {
+		token: string;
+	};
+	[actionName: string]: unknown;
+}
+export interface CommandInterpretation {
+	expectsParams?: boolean;
+	error?: string;
+	mixedCase?: boolean;
+	describe?: string;
+	confirm?: string;
+	commands?: CommandAction[];
+	skipOnlineLookup?: boolean;
+}
+export interface SearchSettingsParams {
+	args: string;
+	kind?: "set" | "show" | "hide";
+}
+export interface SettingsSearchCandidate {
+	key: string;
+	label: string;
+	section: string;
+}
+export interface SettingsSearchResult {
+	found: boolean;
+	query?: string;
+	key?: string;
+	label?: string;
+	section?: string;
+	fieldType?: string;
+	valueLabel?: string;
+	value?: boolean;
+	simple?: boolean;
+	ambiguous?: boolean;
+	candidates?: SettingsSearchCandidate[];
+	newValue?: JSONValue;
+	newValueLabel?: string;
+	unchanged?: boolean;
+	expects?: string;
+}
+export interface CommandCatalogEntry {
+	command: string;
+	describe: string;
+	params?: string;
+	category?: string;
+	needsOperation?: boolean;
+	expectsParams?: boolean;
+	suggest?: boolean;
+}
+export interface CommandHook {
+	interpret(args: {
+		input: string;
+		operation?: Record<string, JSONValue>;
+		qso?: Record<string, JSONValue>;
+		execute?: boolean;
+	}, ctx: HookContext): Promise<CommandInterpretation | null>;
+	catalog?(ctx: HookContext): Promise<CommandCatalogEntry[]>;
+}
+export interface SyncPayload {
+	operations?: Record<string, JSONValue>[];
+	qsos?: Record<string, JSONValue>[];
+	meta?: Record<string, JSONValue>;
+}
+export interface SyncResponse {
+	operations?: Record<string, JSONValue>[];
+	qsos?: Record<string, JSONValue>[];
+	meta?: Record<string, JSONValue>;
+	account?: Record<string, JSONValue>;
+	success?: boolean;
+	error?: string;
+	error_status?: number;
+}
+export interface SyncTransportHook {
+	sync(payload: SyncPayload, ctx: HookContext): Promise<SyncResponse>;
+	getAccountData(args: Record<string, never>, ctx: HookContext): Promise<Record<string, JSONValue>>;
+	linkClient?(args: {
+		email?: string;
+	}, ctx: HookContext): Promise<Record<string, JSONValue>>;
+	linkClientWithEmail(args: {
+		email: string;
+	}, ctx: HookContext): Promise<Record<string, JSONValue>>;
+	setAccountEmail?(args: {
+		email: string;
+	}, ctx: HookContext): Promise<Record<string, JSONValue>>;
+	resendAccountEmail?(args: Record<string, never>, ctx: HookContext): Promise<Record<string, JSONValue>>;
+	findLinkRequest?(args: {
+		challenge_token: string;
+	}, ctx: HookContext): Promise<Record<string, JSONValue>>;
+	findLinkRequestByClient?(args: {
+		client: string;
+		challenge_token: string;
+	}, ctx: HookContext): Promise<Record<string, JSONValue>>;
+	approveLinkRequest?(args: {
+		client: string;
+		challenge_token?: string;
+	}, ctx: HookContext): Promise<Record<string, JSONValue>>;
+	ensureClientRegistered?(args: {
+		refreshWebhookToken?: boolean;
+	}, ctx: HookContext): Promise<{
+		push_channel_name: string;
+		webhook_client_token: string;
+	}>;
+	fetchWebhookEvents?(args: Record<string, never>, ctx: HookContext): Promise<{
+		webhook_events: Record<string, JSONValue>[];
+	}>;
+	submitReport?(args: {
+		title: string;
+		body: string;
+		kind: "idea" | "task" | "bug";
+	}, ctx: HookContext): Promise<{
+		ref?: string | null;
+		error?: string;
+	}>;
+}
+export interface AccountField {
+	key: string;
+	label: string;
+	type: "text" | "email" | "secret";
+	preface?: string;
+	postface?: string;
+}
+export interface OAuth2Config {
+	issuer: string;
+	clientId: string;
+	redirectUrl: string;
+	webhookRedirectUrl?: string;
+	scopes: string[];
+}
+export type Localizable<T> = T | ((args: Record<string, never>, ctx: HookContext) => T | Promise<T>);
+export interface AccountHook {
+	label: Localizable<string>;
+	description?: Localizable<string>;
+	kvKey?: string;
+	fields?: Localizable<AccountField[]>;
+	oauth2?: OAuth2Config | ((args: Record<string, never>, ctx: HookContext) => OAuth2Config | Promise<OAuth2Config>);
+	synchronizable?: boolean;
+	testCredentials(credentials: Record<string, string>, ctx: HookContext): Promise<string>;
+}
+export type Hook = LookupHook | LookupServiceHook | SpotsHook | ExportHook | ScoringHook | RefHandlerHook | ActivityHook | AdifFieldsHook | AdifImportHook | CommandHook | SyncTransportHook | AccountHook | DataFileDefinition | FormHook | SettingsPanelHook | PanelHook | Record<string, unknown>;
+export interface RegisterHookParams {
+	hook: Hook;
+	key?: string;
+	priority?: number;
+}
+export interface ActivationApi {
+	registerHook(category: string, params: RegisterHookParams): void;
+	hostCall(method: string, params: Record<string, unknown>): Promise<unknown>;
+}
+export interface ExtensionManifest {
+	key: string;
+	name: string;
+	shortName?: string;
+	version: string;
+	description?: string;
+	icon?: string;
+	accentColor?: string;
+	keywords?: string[];
+	category?: string;
+	enabledByDefault?: boolean;
+	hooks?: string[];
+	domains?: string[];
+	allowUserAgentOverride?: boolean;
+	requiresLocation?: boolean;
+	experiments?: string[];
+	translations?: Record<string, {
+		name?: string;
+		description?: string;
+		keywords?: string[];
+	}>;
+}
+export interface ExtensionDefinition extends ExtensionManifest {
+	onActivation(api: ActivationApi): void;
+}
+export interface FetchOptions {
+	method?: "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
+	/**
+	 * Extra request headers. Note: the host stamps HaLo's canonical
+	 * `User-Agent` on every request and it overrides any you set here, so
+	 * don't provide your own — unless your extension declares
+	 * `allowUserAgentOverride` in build.mjs (see docs/design/network.md).
+	 */
+	headers?: Record<string, string>;
+	body?: string;
+	/**
+	 * Give up on this request after `timeout` milliseconds, instead of the
+	 * host's default allowance. Clamped DOWNWARD only — asking for longer than
+	 * the default changes nothing — and it bounds the whole request, headers
+	 * and body alike.
+	 *
+	 * For a request whose answer is optional: a cache-validation probe, an
+	 * enrichment worth having but not worth waiting for. It matters because a
+	 * hook fan-out shares ONE budget across every extension in the category,
+	 * so a request that stalls costs the other extensions their results too
+	 * (see `invokeHookAll`'s `partialOnTimeout`). This is how a hook says
+	 * "not worth waiting the default for" rather than spending everyone's time.
+	 */
+	timeout?: number;
+}
+export interface FetchResponse {
+	status: number;
+	body: string;
+}
+export interface DeviceLocation {
+	latitude: number;
+	longitude: number;
+}
+export interface VersionInfo {
+	platform: string;
+	edition: string;
+	version: string;
+	versionName: string;
+	buildNumber: number | null;
+	gitSha: string;
+}
+export interface LookupRow {
+	category: string;
+	subCategory?: string;
+	key: string;
+	name?: string;
+	data?: any;
+	lat?: number;
+	lon?: number;
+	flags?: number;
+}
+export interface LookupEntry {
+	subCategory?: string;
+	key: string;
+	name?: string;
+	lat?: number;
+	lon?: number;
+	flags?: number;
+	data?: Record<string, unknown>;
+}
+export interface CsvOptions {
+	hasHeaders?: boolean;
+	skipRows?: number;
+	delimiter?: string;
+}
+export interface JsonOptions {
+	rootPath?: string;
+}
+export type FetchType = "csv" | "json" | "raw";
+export interface DataFileDefinition {
+	key: string;
+	name: Localizable<string>;
+	description: Localizable<string>;
+	url: Localizable<string>;
+	maxAgeInDays: number;
+	fetchType: FetchType;
+	encoding?: string;
+	category?: string;
+	csvOptions?: CsvOptions;
+	csvToLookupEntry?: (row: string[] | Record<string, string>) => LookupEntry | null;
+	jsonOptions?: JsonOptions;
+	jsonToLookupEntry?: (entry: Record<string, any>) => LookupEntry | null;
+	rawToJSONData?: (args: {
+		body: string;
+		url: string;
+		options: Record<string, any>;
+	}) => Promise<any>;
+	onLoadRawData?: (data: any) => void;
+	onRemoveRawData?: () => Promise<void>;
+}
+export type FormFieldType = "text" | "multiline" | "email" | "callsign" | "number" | "select" | "radio" | "checkbox" | "secret" | "list" | "multiselect" | "account";
+export interface FormFieldOption {
+	label: string;
+	value: any;
+	common?: boolean;
+	uncommon?: boolean;
+}
+export interface FormField {
+	type: "field";
+	fieldType: FormFieldType;
+	key: string;
+	label: string;
+	value?: any;
+	placeholder?: string;
+	uppercase?: boolean;
+	options?: FormFieldOption[] | string;
+	validate?: (value: any, state: Record<string, any>) => string | null | undefined | Promise<string | null | undefined>;
+	transform?: (value: any, state: Record<string, any>) => any | Promise<any>;
+	itemFields?: FormField[];
+	itemTitle?: string;
+	orderable?: boolean;
+	inline?: boolean;
+	itemLabel?: string;
+	defaultValue?: any[];
+	account?: {
+		key: string;
+		subkey?: string;
+	};
+	devMode?: boolean;
+	icon?: string;
+	description?: string;
+	visibleWhen?: {
+		field: string;
+		equals: any;
+	};
+	common?: boolean;
+	environment?: string | string[];
+	target?: string | string[];
+	restartOnChange?: boolean;
+}
+export interface FormHeader {
+	type: "header";
+	title: string;
+	subtitle?: string;
+	devMode?: boolean;
+	style?: "default" | "section";
+	environment?: string | string[];
+}
+export interface FormSectionDivider {
+	type: "divider";
+	title?: string;
+	devMode?: boolean;
+	environment?: string | string[];
+}
+export interface FormMarkdownBlock {
+	type: "markdown";
+	text: string;
+	devMode?: boolean;
+	environment?: string | string[];
+	collapsible?: boolean;
+	title?: string;
+}
+export interface FormActionElement {
+	type: "action";
+	key: string;
+	label: string;
+	method: string;
+	devMode?: boolean;
+	common?: boolean;
+	environment?: string | string[];
+	target?: string | string[];
+}
+export interface FormLinkElement {
+	type: "link";
+	key?: string;
+	label: string;
+	url: string;
+	icon?: string;
+	description?: string;
+	devMode?: boolean;
+	common?: boolean;
+	environment?: string | string[];
+}
+export type FormElement = FormField | FormHeader | FormSectionDivider | FormMarkdownBlock | FormActionElement | FormLinkElement;
+export interface FormDefinition {
+	title?: string;
+	subtitle?: string;
+	elements: FormElement[];
+	onChange?: (fieldKey: string, value: any, state: Record<string, any>) => Promise<Record<string, any> | void> | Record<string, any> | void;
+}
+export interface FormHook {
+	getDefinition(args: {
+		formId?: string;
+	}, ctx: HookContext): Promise<FormDefinition>;
+	validateField?(args: {
+		formId?: string;
+		fieldKey: string;
+		value: any;
+		state: Record<string, any>;
+	}, ctx: HookContext): Promise<string | null>;
+	transformField?(args: {
+		formId?: string;
+		fieldKey: string;
+		value: any;
+		state: Record<string, any>;
+	}, ctx: HookContext): Promise<any>;
+	onChangeField?(args: {
+		formId?: string;
+		fieldKey: string;
+		value: any;
+		state: Record<string, any>;
+	}, ctx: HookContext): Promise<Record<string, any> | null | void>;
+}
+export interface SettingsPanelDescriptor {
+	key: string;
+	title: string;
+	icon?: string;
+	order?: number;
+	sidebar?: boolean;
+	dataFilesSection?: boolean;
+}
+export interface SettingsField extends Omit<FormField, "validate" | "transform" | "itemFields"> {
+	pattern?: string;
+	patternError?: string;
+	itemFields?: SettingsField[];
+	aliases?: string | string[];
+}
+export interface SimpleSettingsPanel {
+	kind: "simple";
+	key?: string;
+	title: string;
+	icon?: string;
+	order?: number;
+	sidebar?: boolean;
+	dataFilesSection?: boolean;
+	fields: (SettingsField | FormActionElement)[];
+}
+export interface DynamicSettingsPanel {
+	kind: "dynamic";
+	key?: string;
+	getPanels?(args: Record<string, never>, ctx: HookContext): Promise<SettingsPanelDescriptor[]>;
+	getDefinition(args: {
+		panelKey: string;
+	}, ctx: HookContext): Promise<FormDefinition>;
+	validateField?(args: {
+		panelKey: string;
+		fieldKey: string;
+		value: any;
+		state: Record<string, any>;
+	}, ctx: HookContext): Promise<string | null>;
+	transformField?(args: {
+		panelKey: string;
+		fieldKey: string;
+		value: any;
+		state: Record<string, any>;
+	}, ctx: HookContext): Promise<any>;
+	onChangeField(args: {
+		panelKey: string;
+		fieldKey: string;
+		value: any;
+		state: Record<string, any>;
+	}, ctx: HookContext): Promise<void>;
+}
+export type SettingsPanelHook = SimpleSettingsPanel | DynamicSettingsPanel;
+export type NoticeAction = {
+	label: string;
+	type: "link";
+	url: string;
+} | {
+	label: string;
+	type: "dialog";
+	title?: string;
+	text: string;
+} | {
+	label: string;
+	type: "account";
+	key: string;
+	subkey?: string;
+};
+export interface StatusBarMessageParams {
+	key: string;
+	icon?: string;
+	title?: string;
+	text?: string;
+}
+export interface StatusBarProgressParams {
+	key: string;
+	icon?: string;
+	title?: string;
+	text?: string;
+	value?: number;
+}
+export interface StatusBarNoticeParams {
+	key: string;
+	icon?: string;
+	title?: string;
+	text: string;
+	actions?: NoticeAction[];
+}
+export type PanelTrigger = "operation" | "qso" | "qsoLogged" | "lookup" | "spots" | `tick:${number}`;
+export interface PanelDescriptor {
+	key: string;
+	title: string;
+	description?: string;
+	icon?: string;
+	preview?: string;
+	on?: PanelTrigger[];
+	multiple?: boolean;
+	form?: SettingsField[];
+}
+export interface PanelRenderArgs {
+	panelKey: string;
+	operation: Record<string, JSONValue>;
+	qso?: Record<string, JSONValue>;
+	qsoCount: number;
+	config: Record<string, JSONValue>;
+	reason: string;
+}
+export type PanelContent = {
+	kind: "markdown";
+	content: string;
+	title?: string;
+	triggers?: string[];
+} | {
+	kind: "svg";
+	content: string;
+	title?: string;
+	triggers?: string[];
+} | {
+	kind: "html";
+	content: string;
+	title?: string;
+	triggers?: string[];
+};
+export interface PanelHook {
+	getPanels(args: Record<string, never>, ctx: HookContext): Promise<PanelDescriptor[]>;
+	render(args: PanelRenderArgs, ctx: HookContext): Promise<PanelContent>;
+}
+/**
+ * The standard per-extension translator: takes the extension's i18next
+ * resources once and returns a `tFor(ctx)` that hooks call with their
+ * HookContext. The underlying i18next instance is rebuilt only when
+ * `ctx.locale` changes (it only does when the app's locale setting does).
+ * Typical use, with per-locale JSON catalogs:
+ *
+ *   import en from "./i18n/en.json" with { type: "json" }
+ *   import es from "./i18n/es.json" with { type: "json" }
+ *   export const tFor = createCachedTranslator({ en: { translation: en }, es: { translation: es } })
+ */
+export declare function createCachedTranslator(resources: Record<string, any>): (ctx: {
+	locale?: string;
+}) => ReturnType<typeof createTranslator>;
+/**
+ * Creates a lightweight translator function using an i18next instance
+ * initialized with the given resources and active locale.
+ */
+export declare function createTranslator(resources: Record<string, any>, currentLocale: string): (key: string, options?: any) => string;
+export interface ParsedCallsign {
+	call: string;
+	baseCall?: string;
+	prefix?: string;
+	extendedPrefix?: string;
+	ituPrefix?: string;
+	digit?: string;
+	preindicator?: string;
+	postindicators?: string[];
+	prefixOverride?: string;
+	indicators?: string[];
+	ssid?: string;
+}
+export type CombinedCallInfo = ParsedCallsign & {
+	isoPrefix?: string;
+	dxccCode?: number;
+	regionCode?: string;
+	state?: string;
+	entityPrefix?: string;
+	entityName?: string;
+	continent?: string;
+	cqZone?: number;
+	ituZone?: number;
+	lat?: number;
+	lon?: number;
+	tz?: string;
+	matchSource?: string;
+	matchNote?: string;
+	locSource?: string;
+};
+type AnnotatedCallInfo$1 = CombinedCallInfo & {
+	originalValues?: AnnotatedCallInfo$1;
+	cfValues?: AnnotatedCallInfo$1;
+};
+export declare function annotateCallAgainstCountryFile(call: string): AnnotatedCallInfo$1;
+export declare function entityPrefixForCall(call: string | undefined): string | undefined;
+export declare function flagForDxccCode(dxccCode: number | undefined): string | undefined;
+export declare function regionAndCountryForDxccCode(dxccCode: number | undefined): {
+	ituRegion?: number;
+	countryCode?: string;
+};
+export declare const LOCATION_ACCURACY: {
+	readonly EXACT: 0;
+	readonly ACCURATE: 2;
+	readonly REASONABLE: 10;
+	readonly VAGUE: 100;
+	readonly NO_LOCATION: 1000;
+};
+export declare function applyLatLonFromApiFields(target: {
+	lat?: number;
+	lon?: number;
+}, raw: Record<string, unknown>): void;
+export declare function canonicalMode(mode: string): string;
+export declare function modesMatchForDupe(worked: string, candidate: string): boolean;
+export interface ContestScorerOptions {
+	scope?: ScoringScope;
+}
+export declare function contestScorer<S extends Scoresheet = Scoresheet>(scorer: ContestScorer<S>, options?: ContestScorerOptions): ScoringHook & {
+	scope: ScoringScope;
+};
+export declare function tally(key: string, forScope: "day" | "operation", total: number, extra?: Partial<ScoreTally>): ScoreTally;
+export type UniqueAxis = "day" | "band" | "mode" | "ref";
+export interface ActivityScoringRules {
+	label: string;
+	icon?: string;
+	activationType: string;
+	huntingType?: string;
+	qsosToActivate?: number | ((activatedRefs: string[]) => number);
+	tracksActivation?: boolean;
+	freshRefRescuesActivation?: boolean;
+	allowsMultipleReferences?: boolean;
+	uniquePer?: readonly UniqueAxis[];
+	activates?: "daily" | "once";
+	refNoun?: string | ((ctx: HookContext) => string);
+	refNounPlural?: string | ((ctx: HookContext) => string);
+	p2pLabel?: string | ((ctx: HookContext) => string);
+}
+export type ActivityScoresheet = {
+	workedByCall: Record<string, string[]>;
+	activatedRefs: Record<string, number>;
+	huntedRefs: Record<string, number>;
+	activatedQsos: number;
+	huntedQsos: number;
+	duplicates: number;
+	dayActivatedRefs: Record<string, number>;
+	dayHuntedRefs: Record<string, number>;
+	dayActivatedQsos: number;
+	dayHuntedQsos: number;
+	dayDuplicates: number;
+};
+export declare function activityScorer(rules: ActivityScoringRules): ContestScorer<ActivityScoresheet>;
+export interface ActivityExportRules {
+	key: string;
+	label: string;
+	activationType: string;
+	icon?: string;
+	includeFieldsFrom?: string[];
+}
+export declare function activityExportHook(rules: ActivityExportRules): {
+	suggestExportOptions({ operation, qsos, compactFilenames }: ExportOptionsRequest, ctx: HookContext): Promise<ExportOption[]>;
+	generateExport(args: ExportRequest, ctx: HookContext): Promise<ExportResult>;
+};
+export interface HuntingExportRules {
+	key: string;
+	label: string;
+	huntingType: string;
+	activationType: string;
+	icon?: string;
+	color?: string;
+	includeFieldsFrom?: string[];
+}
+export declare function huntingExportHook(rules: HuntingExportRules): {
+	suggestExportOptions({ operation, qsos, compactFilenames }: ExportOptionsRequest, ctx: HookContext): Promise<ExportOption[]>;
+	generateExport(args: ExportRequest, ctx: HookContext): Promise<ExportResult>;
+};
+export declare function adifForExport({ operation, qsos, includePrivateData, mainHandler, includeFieldsFrom }: {
+	operation: Record<string, JSONValue>;
+	qsos: Record<string, JSONValue>[];
+	includePrivateData?: boolean;
+	mainHandler: string;
+	includeFieldsFrom?: string[];
+}): Promise<string>;
+export interface ActivityAdifImportRules {
+	sig: string;
+	huntingType?: string;
+	activationType: string;
+	refField?: string;
+	normalize?: (ref: string) => string;
+}
+export declare function activityAdifImport(rules: ActivityAdifImportRules): AdifImportHook;
+export interface ExportNameParts {
+	stationCall?: JSONValue;
+	ref?: string;
+	activity?: string;
+	modifier?: string;
+	startAtMillis?: number;
+	extension: string;
+	compact?: boolean;
+}
+export declare function exportFilename(parts: ExportNameParts): string;
+export declare function startMillisOf(operation: Record<string, JSONValue>, qsos?: Record<string, JSONValue>[]): number | undefined;
+export interface ReferenceActivityConfig {
+	key: string;
+	label: string;
+	activationType: string;
+	huntingType?: string;
+	splitRecordsPerHuntedRef?: boolean;
+	referenceRegex: RegExp;
+	icon?: string;
+	color?: string;
+	placeholder?: string;
+	category?: string;
+	tFor: (ctx: {
+		locale?: string;
+	}) => (key: string) => string;
+	adifProgram?: string;
+	adifRefField?: string;
+	allowsMultiple?: boolean;
+	linkUrl?: (reference: string) => string;
+}
+export interface ReferenceActivityHooks {
+	refHandler: Record<string, unknown>;
+	activityHook: Record<string, unknown>;
+	adifFieldsHook: Record<string, unknown>;
+	adifImportHook: AdifImportHook;
+}
+export declare function referenceActivity(config: ReferenceActivityConfig): ReferenceActivityHooks;
+export declare class TemplateError extends Error {
+	readonly cause?: unknown;
+	constructor(message: string, options?: {
+		cause?: unknown;
+	});
+}
+export declare function renderTemplate(template: string, context: Record<string, unknown>, label?: string): string;
+export declare function oneLine(text: string): string;
+export declare function triggersForTemplate(template: string): string[];
+export declare function utcDate(millis: number): string;
+export declare function utcDateCompact(millis: number): string;
+export declare function utcTime(millis: number): string;
+export declare function utcIso(millis: number): string;
+export declare function dateValues(millis: number): Record<string, JSONValue>;
+export declare function opValues(operation: Record<string, JSONValue>, extra?: {
+	qsoCount?: number;
+	atMillis?: number;
+}): Record<string, JSONValue>;
+export declare function qsoValues(qso: Record<string, JSONValue>): Record<string, JSONValue>;
+export interface LogValues {
+	station?: string;
+	ref?: string;
+	refName?: string;
+	refShortName?: string;
+	activity?: string;
+	handlerName?: string;
+	handlerShortName?: string;
+	format?: string;
+	exportType?: string;
+	modifier?: string;
+	extension?: string;
+	compact?: boolean;
+}
+export declare function logValues(values: LogValues): Record<string, JSONValue>;
+export interface TemplateContextArgs {
+	operation?: Record<string, JSONValue>;
+	qso?: Record<string, JSONValue>;
+	qsoCount?: number;
+	config?: Record<string, JSONValue>;
+	log?: LogValues;
+	appName?: string;
+	atMillis?: number;
+	nowMillis?: number;
+}
+export declare function templateContext(args: TemplateContextArgs): Record<string, unknown>;
+export declare function isTestOperation(stationCall: JSONValue | undefined): boolean;
+export declare function defineExtension(def: ExtensionDefinition): void;
+export declare const hooks: {
+	invokeAll(category: string, method: string, args: unknown, online?: boolean): Promise<{
+		key: string;
+		ok: boolean;
+		value?: unknown;
+		error?: string;
+	}[]>;
+	invokeOne(category: string, key: string, method: string, args: unknown, online?: boolean): Promise<{
+		key: string;
+		ok: boolean;
+		value?: unknown;
+		error?: string;
+	}[]>;
+	invokeAllSequential(category: string, method: string, initialArgs: unknown, fold: (args: unknown, hookResult: unknown, hookKey: string) => unknown, online?: boolean): Promise<{
+		key: string;
+		ok: boolean;
+		value?: unknown;
+		error?: string;
+	}[]>;
+};
+export declare const host: {
+	fetch(url: string, options?: FetchOptions): Promise<FetchResponse>;
+	kvGet(key: string): Promise<JSONValue | null>;
+	getLocation(): Promise<DeviceLocation | null>;
+	getVersionInfo(): Promise<VersionInfo>;
+	getSettings(): Promise<Record<string, JSONValue>>;
+	setSettings(values: Record<string, JSONValue>): Promise<void>;
+	searchSettings(params: SearchSettingsParams): Promise<SettingsSearchResult>;
+	kvSet(key: string, value: JSONValue): Promise<void>;
+	setAccountSession(session: Record<string, string>): Promise<void>;
+	showMessage(message: ResultMessage): Promise<void>;
+	translate(key: string): Promise<string | null>;
+	translateAll(keys: string[]): Promise<Record<string, string | null>>;
+	secret(name: string): Promise<string | null>;
+	dbLookupSelectOne(category: string, key: string): Promise<LookupRow | null>;
+	dbLookupSelectAll(category: string, query: string, subCategory?: string, activeOnly?: boolean): Promise<LookupRow[]>;
+	dbLookupSelectByLocation(category: string, lat: number, lon: number, delta: number, activeOnly?: boolean): Promise<LookupRow[]>;
+	showForm(form: FormDefinition, state?: Record<string, any>): Promise<Record<string, any> | null>;
+	statusBar: {
+		setMessage(params: StatusBarMessageParams): Promise<void>;
+		setProgress(params: StatusBarProgressParams): Promise<void>;
+		clear(key: string): Promise<void>;
+		showNotice(params: StatusBarNoticeParams): Promise<void>;
+		dismissNotice(key: string): Promise<void>;
+	};
+	log(message: string): void;
+	updateInterpretation(input: string, interpretation: Record<string, unknown>): void;
+};
+
+export {};