@comms-id/asx 0.4.0 → 0.4.2

package/dist/search-service.js

@@ -0,0 +1,64 @@
+import { Effect, Result, Schema } from "effect";
+import { SuggestionsResponse } from "./client-replies.js";
+import { suggestDirectory } from "./directory-search.js";
+import { failure, Failure, isFallbackEligible, isTimestamp } from "./model.js";
+const searchSource = Effect.fn("ASX.searchSource")(function* (sources, source, query, limit) {
+    const read = sources[source];
+    if (!read)
+        return yield* Effect.fail(failure(source === "live" ? "CONFIGURATION_ERROR" : "SNAPSHOT_UNAVAILABLE"));
+    const input = yield* Effect.tryPromise({
+        try: (signal) => read(query, limit, signal),
+        catch: (error) => source === "snapshot"
+            ? failure("SNAPSHOT_UNAVAILABLE")
+            : Schema.is(Failure)(error)
+                ? failure(error.code)
+                : failure("TRANSPORT_FAILED"),
+    });
+    const reply = yield* Schema.decodeUnknownEffect(SuggestionsResponse)(input).pipe(Effect.mapError(() => failure(source === "snapshot" ? "SNAPSHOT_UNAVAILABLE" : "PARSE_FAILED")));
+    if (reply.source !== source)
+        return yield* Effect.fail(failure("SOURCE_MISMATCH"));
+    if (!isTimestamp(reply.directoryObservedAt) ||
+        reply.suggestions.length > limit ||
+        new Set(reply.suggestions.map((entry) => entry.ticker)).size !== reply.suggestions.length ||
+        reply.suggestions.some((entry) => !entry.companyName.trim()) ||
+        (reply.source === "snapshot" && reply.fallbackReason !== undefined))
+        return yield* Effect.fail(failure(source === "snapshot" ? "SNAPSHOT_UNAVAILABLE" : "PARSE_FAILED"));
+    return reply;
+});
+const search = Effect.fn("ASX.search")(function* (sources, query, limit, mode) {
+    yield* Effect.try({
+        try: () => suggestDirectory([], query, limit),
+        catch: () => failure("INVALID_INPUT"),
+    });
+    if (!["live", "snapshot", "live-first"].includes(mode))
+        return yield* Effect.fail(failure("INVALID_INPUT"));
+    if (mode === "snapshot")
+        return yield* searchSource(sources, "snapshot", query, limit);
+    const live = yield* searchSource(sources, "live", query, limit).pipe(Effect.result);
+    if (Result.isSuccess(live))
+        return live.success;
+    if (mode === "live" || !isFallbackEligible(live.failure.code))
+        return yield* Effect.fail(live.failure);
+    const saved = yield* searchSource(sources, "snapshot", query, limit);
+    return { ...saved, fallbackReason: live.failure.code };
+});
+/** Read-only search composition. Live-first acquires saved evidence only after an eligible outage. */
+export function createAsxSearchService(sources) {
+    return {
+        suggest: async (query, options = {}) => {
+            try {
+                const result = await Effect.runPromise(Effect.result(search(sources, query, options.limit ?? 8, options.mode ?? "snapshot")), { signal: options.signal });
+                if (Result.isFailure(result))
+                    throw result.failure;
+                return result.success;
+            }
+            catch (error) {
+                throw options.signal?.aborted
+                    ? failure("CANCELLED")
+                    : Schema.is(Failure)(error)
+                        ? failure(error.code)
+                        : failure("INTERNAL_ERROR");
+            }
+        },
+    };
+}

package/dist/service.d.ts

@@ -0,0 +1,35 @@
+import { type AsxError, Observation } from "./model.js";
+import { type ConfirmedEnrichment } from "./enrichment.js";
+export type LookupMode = "live" | "snapshot" | "live-first";
+export type LookupReply = {
+    readonly status: "found";
+    readonly source: "live";
+    readonly observation: Observation;
+} | {
+    readonly status: "missing";
+    readonly source: "live";
+    readonly startedAt: string;
+    readonly observedAt: string;
+} | {
+    readonly status: "found";
+    readonly source: "snapshot";
+    readonly observation: Observation;
+    readonly generation: string;
+    readonly enrichment?: ConfirmedEnrichment;
+    readonly requiresRecheck: true;
+    readonly fallbackReason?: AsxError["code"];
+} | {
+    readonly status: "missing";
+    readonly source: "snapshot";
+    readonly generation: string;
+};
+export interface AsxSources {
+    readonly live?: (ticker: string, signal: AbortSignal) => Promise<unknown>;
+    readonly snapshot?: (ticker: string, signal: AbortSignal) => Promise<unknown>;
+}
+export declare function createAsxService(sources: AsxSources): {
+    lookup: (ticker: string, options?: {
+        mode?: LookupMode;
+        signal?: AbortSignal;
+    }) => Promise<LookupReply>;
+};

package/dist/service.js

@@ -0,0 +1,99 @@
+import { Effect, Fiber, Result, Schema } from "effect";
+import { failure, Failure, isFallbackEligible, isTimestamp, LiveOutcome, Observation, validObservation, } from "./model.js";
+import { normalizeTicker } from "./parse.js";
+import { SnapshotOutcome } from "./snapshot.js";
+import { validEnrichment } from "./enrichment.js";
+function safeError(error, fallback) {
+    return Schema.is(Failure)(error) ? failure(error.code) : failure(fallback);
+}
+const liveLookup = Effect.fn("ASX.live")(function* (sources, ticker) {
+    const live = sources.live;
+    if (!live)
+        return yield* Effect.fail(failure("CONFIGURATION_ERROR"));
+    const input = yield* Effect.tryPromise({
+        try: (signal) => live(ticker, signal),
+        catch: (error) => safeError(error, "TRANSPORT_FAILED"),
+    });
+    const decoded = yield* Schema.decodeUnknownEffect(LiveOutcome)(input).pipe(Effect.mapError(() => failure("PARSE_FAILED")));
+    if (decoded.status === "missing") {
+        if (!isTimestamp(decoded.observedAt) ||
+            !isTimestamp(decoded.startedAt) ||
+            decoded.startedAt > decoded.observedAt)
+            return yield* Effect.fail(failure("PARSE_FAILED"));
+    }
+    else {
+        if (!validObservation(decoded.observation))
+            return yield* Effect.fail(failure("PARSE_FAILED"));
+        if (decoded.observation.company.ticker !== ticker)
+            return yield* Effect.fail(failure("SOURCE_MISMATCH"));
+    }
+    return decoded;
+});
+const snapshotLookup = Effect.fn("ASX.snapshot")(function* (sources, ticker) {
+    const snapshot = sources.snapshot;
+    if (!snapshot)
+        return yield* Effect.fail(failure("SNAPSHOT_UNAVAILABLE"));
+    const input = yield* Effect.tryPromise({
+        try: (signal) => snapshot(ticker, signal),
+        catch: () => failure("SNAPSHOT_UNAVAILABLE"),
+    });
+    const reply = yield* Schema.decodeUnknownEffect(SnapshotOutcome)(input).pipe(Effect.mapError(() => failure("SNAPSHOT_UNAVAILABLE")));
+    if (!/^[a-f0-9]{64}$/.test(reply.generation) || reply.status === "unavailable")
+        return yield* Effect.fail(failure("SNAPSHOT_UNAVAILABLE"));
+    if (reply.status === "found" &&
+        (!Schema.is(Observation)(reply.observation) ||
+            !validObservation(reply.observation) ||
+            reply.observation.company.ticker !== ticker ||
+            (reply.enrichment !== undefined &&
+                !validEnrichment(reply.enrichment, reply.observation.company))))
+        return yield* Effect.fail(failure("SNAPSHOT_UNAVAILABLE"));
+    return reply;
+});
+const lookup = Effect.fn("ASX.lookup")(function* (sources, input, mode) {
+    const ticker = yield* Effect.try({
+        try: () => normalizeTicker(input),
+        catch: () => failure("INVALID_INPUT"),
+    });
+    if (!["live", "snapshot", "live-first"].includes(mode))
+        return yield* Effect.fail(failure("INVALID_INPUT"));
+    if (mode === "snapshot") {
+        const saved = yield* snapshotLookup(sources, ticker);
+        return saved.status === "missing"
+            ? { ...saved, source: "snapshot" }
+            : { ...saved, source: "snapshot", requiresRecheck: true };
+    }
+    const saved = mode === "live-first" && sources.snapshot
+        ? yield* snapshotLookup(sources, ticker).pipe(Effect.result, Effect.forkChild({ startImmediately: true }))
+        : undefined;
+    const live = yield* liveLookup(sources, ticker).pipe(Effect.result);
+    if (Result.isSuccess(live))
+        return { ...live.success, source: "live" };
+    if (!isFallbackEligible(live.failure.code) || !saved)
+        return yield* Effect.fail(live.failure);
+    const result = yield* Fiber.join(saved);
+    if (Result.isFailure(result))
+        return yield* Effect.fail(result.failure);
+    if (result.success.status === "missing")
+        return yield* Effect.fail(live.failure);
+    return {
+        ...result.success,
+        source: "snapshot",
+        requiresRecheck: true,
+        fallbackReason: live.failure.code,
+    };
+});
+export function createAsxService(sources) {
+    return {
+        lookup: async (ticker, options = {}) => {
+            try {
+                const result = await Effect.runPromise(Effect.result(lookup(sources, ticker, options.mode ?? "live-first")), { signal: options.signal });
+                if (Result.isFailure(result))
+                    throw result.failure;
+                return result.success;
+            }
+            catch (error) {
+                throw options.signal?.aborted ? failure("CANCELLED") : safeError(error, "INTERNAL_ERROR");
+            }
+        },
+    };
+}

package/dist/snapshot.d.ts

@@ -0,0 +1,328 @@
+import { Schema } from "effect";
+import { DirectoryEntry } from "./model.js";
+import { ConfirmedEnrichment } from "./enrichment.js";
+/**
+ * An ABN matched to a listed company by the owner-accepted name rules (#385): the
+ * full legal name, one trailing company suffix removed, a trailing "(THE)" moved to
+ * the front, or a comma ignored. A name match, never proof of issuer identity.
+ */
+export declare const AbnNameMatch: Schema.Struct<{
+    readonly abn: Schema.String;
+    readonly acn: Schema.NullOr<Schema.String>;
+    readonly abnEntityName: Schema.NonEmptyString;
+    readonly rule: Schema.Literals<readonly ["full-name", "suffix-removed", "the-moved", "comma-ignored"]>;
+    readonly abnSnapshotDate: Schema.String;
+}>;
+export interface AbnNameMatch extends Schema.Schema.Type<typeof AbnNameMatch> {
+}
+export declare const CompanyRecord: Schema.Struct<{
+    readonly directory: Schema.Struct<{
+        readonly ticker: Schema.String;
+        readonly companyName: Schema.String;
+        readonly industryGroup: Schema.NullOr<Schema.String>;
+        readonly listingDate: Schema.NullOr<Schema.String>;
+        readonly marketCapitalisation: Schema.NullOr<Schema.Number>;
+    }>;
+    readonly observation: Schema.NullOr<Schema.Struct<{
+        readonly company: Schema.Struct<{
+            readonly raw: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+            readonly ticker: Schema.String;
+            readonly sourceId: Schema.String;
+            readonly companyName: Schema.String;
+            readonly address: Schema.NullOr<Schema.String>;
+            readonly tel: Schema.NullOr<Schema.String>;
+            readonly fax: Schema.NullOr<Schema.String>;
+            readonly website: Schema.NullOr<Schema.String>;
+            readonly description: Schema.NullOr<Schema.String>;
+            readonly issueType: Schema.NullOr<Schema.String>;
+            readonly foreignExempt: Schema.NullOr<Schema.Boolean>;
+            readonly people: Schema.$Array<Schema.Struct<{
+                readonly sourceName: Schema.String;
+                readonly displayName: Schema.String;
+                readonly title: Schema.String;
+                readonly sourceCategory: Schema.Literals<readonly ["directors", "secretaries"]>;
+            }>>;
+        }>;
+        readonly startedAt: Schema.String;
+        readonly observedAt: Schema.String;
+        readonly lastChangedAt: Schema.String;
+    }>>;
+    readonly sources: Schema.optionalKey<Schema.Struct<{
+        readonly asx: Schema.optionalKey<Schema.Struct<{
+            readonly source: Schema.Literals<readonly ["asx", "morningstar", "google-finance"]>;
+            readonly ticker: Schema.String;
+            readonly sourceUrl: Schema.String;
+            readonly sourceId: Schema.NonEmptyString;
+            readonly status: Schema.Literals<readonly ["found", "missing"]>;
+            readonly startedAt: Schema.String;
+            readonly observedAt: Schema.String;
+            readonly payload: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+            readonly websites: Schema.$Array<Schema.String>;
+        }>>;
+        readonly morningstar: Schema.optionalKey<Schema.Struct<{
+            readonly source: Schema.Literals<readonly ["asx", "morningstar", "google-finance"]>;
+            readonly ticker: Schema.String;
+            readonly sourceUrl: Schema.String;
+            readonly sourceId: Schema.NonEmptyString;
+            readonly status: Schema.Literals<readonly ["found", "missing"]>;
+            readonly startedAt: Schema.String;
+            readonly observedAt: Schema.String;
+            readonly payload: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+            readonly websites: Schema.$Array<Schema.String>;
+        }>>;
+        readonly "google-finance": Schema.optionalKey<Schema.Struct<{
+            readonly source: Schema.Literals<readonly ["asx", "morningstar", "google-finance"]>;
+            readonly ticker: Schema.String;
+            readonly sourceUrl: Schema.String;
+            readonly sourceId: Schema.NonEmptyString;
+            readonly status: Schema.Literals<readonly ["found", "missing"]>;
+            readonly startedAt: Schema.String;
+            readonly observedAt: Schema.String;
+            readonly payload: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+            readonly websites: Schema.$Array<Schema.String>;
+        }>>;
+    }>>;
+    readonly enrichment: Schema.optionalKey<Schema.Struct<{
+        readonly ticker: Schema.String;
+        readonly sourceId: Schema.NonEmptyString;
+        readonly abn: Schema.String;
+        readonly acn: Schema.NullOr<Schema.String>;
+        readonly legalName: Schema.NonEmptyString;
+        readonly identityEvidence: Schema.Struct<{
+            readonly url: Schema.String;
+            readonly sha256: Schema.String;
+            readonly observedAt: Schema.String;
+            readonly kind: Schema.Literals<readonly ["issuer-filing", "issuer-website"]>;
+        }>;
+        readonly abrEvidence: Schema.Struct<{
+            readonly source: Schema.Literals<readonly ["abr-live", "abr-snapshot"]>;
+            readonly observedAt: Schema.String;
+        }>;
+        readonly website: Schema.NullOr<Schema.Struct<{
+            readonly url: Schema.String;
+            readonly evidence: Schema.Struct<{
+                readonly url: Schema.String;
+                readonly sha256: Schema.String;
+                readonly observedAt: Schema.String;
+                readonly kind: Schema.Literals<readonly ["issuer-filing", "issuer-website"]>;
+            }>;
+        }>>;
+    }>>;
+    readonly abnNameMatch: Schema.optionalKey<Schema.Struct<{
+        readonly abn: Schema.String;
+        readonly acn: Schema.NullOr<Schema.String>;
+        readonly abnEntityName: Schema.NonEmptyString;
+        readonly rule: Schema.Literals<readonly ["full-name", "suffix-removed", "the-moved", "comma-ignored"]>;
+        readonly abnSnapshotDate: Schema.String;
+    }>>;
+    readonly missingAt: Schema.optionalKey<Schema.Struct<{
+        readonly startedAt: Schema.String;
+        readonly observedAt: Schema.String;
+    }>>;
+}>;
+export interface CompanyRecord extends Schema.Schema.Type<typeof CompanyRecord> {
+}
+declare const Dataset: Schema.Struct<{
+    readonly formatVersion: Schema.Literal<1>;
+    readonly directoryObservedAt: Schema.String;
+    readonly records: Schema.$Array<Schema.Struct<{
+        readonly directory: Schema.Struct<{
+            readonly ticker: Schema.String;
+            readonly companyName: Schema.String;
+            readonly industryGroup: Schema.NullOr<Schema.String>;
+            readonly listingDate: Schema.NullOr<Schema.String>;
+            readonly marketCapitalisation: Schema.NullOr<Schema.Number>;
+        }>;
+        readonly observation: Schema.NullOr<Schema.Struct<{
+            readonly company: Schema.Struct<{
+                readonly raw: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+                readonly ticker: Schema.String;
+                readonly sourceId: Schema.String;
+                readonly companyName: Schema.String;
+                readonly address: Schema.NullOr<Schema.String>;
+                readonly tel: Schema.NullOr<Schema.String>;
+                readonly fax: Schema.NullOr<Schema.String>;
+                readonly website: Schema.NullOr<Schema.String>;
+                readonly description: Schema.NullOr<Schema.String>;
+                readonly issueType: Schema.NullOr<Schema.String>;
+                readonly foreignExempt: Schema.NullOr<Schema.Boolean>;
+                readonly people: Schema.$Array<Schema.Struct<{
+                    readonly sourceName: Schema.String;
+                    readonly displayName: Schema.String;
+                    readonly title: Schema.String;
+                    readonly sourceCategory: Schema.Literals<readonly ["directors", "secretaries"]>;
+                }>>;
+            }>;
+            readonly startedAt: Schema.String;
+            readonly observedAt: Schema.String;
+            readonly lastChangedAt: Schema.String;
+        }>>;
+        readonly sources: Schema.optionalKey<Schema.Struct<{
+            readonly asx: Schema.optionalKey<Schema.Struct<{
+                readonly source: Schema.Literals<readonly ["asx", "morningstar", "google-finance"]>;
+                readonly ticker: Schema.String;
+                readonly sourceUrl: Schema.String;
+                readonly sourceId: Schema.NonEmptyString;
+                readonly status: Schema.Literals<readonly ["found", "missing"]>;
+                readonly startedAt: Schema.String;
+                readonly observedAt: Schema.String;
+                readonly payload: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+                readonly websites: Schema.$Array<Schema.String>;
+            }>>;
+            readonly morningstar: Schema.optionalKey<Schema.Struct<{
+                readonly source: Schema.Literals<readonly ["asx", "morningstar", "google-finance"]>;
+                readonly ticker: Schema.String;
+                readonly sourceUrl: Schema.String;
+                readonly sourceId: Schema.NonEmptyString;
+                readonly status: Schema.Literals<readonly ["found", "missing"]>;
+                readonly startedAt: Schema.String;
+                readonly observedAt: Schema.String;
+                readonly payload: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+                readonly websites: Schema.$Array<Schema.String>;
+            }>>;
+            readonly "google-finance": Schema.optionalKey<Schema.Struct<{
+                readonly source: Schema.Literals<readonly ["asx", "morningstar", "google-finance"]>;
+                readonly ticker: Schema.String;
+                readonly sourceUrl: Schema.String;
+                readonly sourceId: Schema.NonEmptyString;
+                readonly status: Schema.Literals<readonly ["found", "missing"]>;
+                readonly startedAt: Schema.String;
+                readonly observedAt: Schema.String;
+                readonly payload: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+                readonly websites: Schema.$Array<Schema.String>;
+            }>>;
+        }>>;
+        readonly enrichment: Schema.optionalKey<Schema.Struct<{
+            readonly ticker: Schema.String;
+            readonly sourceId: Schema.NonEmptyString;
+            readonly abn: Schema.String;
+            readonly acn: Schema.NullOr<Schema.String>;
+            readonly legalName: Schema.NonEmptyString;
+            readonly identityEvidence: Schema.Struct<{
+                readonly url: Schema.String;
+                readonly sha256: Schema.String;
+                readonly observedAt: Schema.String;
+                readonly kind: Schema.Literals<readonly ["issuer-filing", "issuer-website"]>;
+            }>;
+            readonly abrEvidence: Schema.Struct<{
+                readonly source: Schema.Literals<readonly ["abr-live", "abr-snapshot"]>;
+                readonly observedAt: Schema.String;
+            }>;
+            readonly website: Schema.NullOr<Schema.Struct<{
+                readonly url: Schema.String;
+                readonly evidence: Schema.Struct<{
+                    readonly url: Schema.String;
+                    readonly sha256: Schema.String;
+                    readonly observedAt: Schema.String;
+                    readonly kind: Schema.Literals<readonly ["issuer-filing", "issuer-website"]>;
+                }>;
+            }>>;
+        }>>;
+        readonly abnNameMatch: Schema.optionalKey<Schema.Struct<{
+            readonly abn: Schema.String;
+            readonly acn: Schema.NullOr<Schema.String>;
+            readonly abnEntityName: Schema.NonEmptyString;
+            readonly rule: Schema.Literals<readonly ["full-name", "suffix-removed", "the-moved", "comma-ignored"]>;
+            readonly abnSnapshotDate: Schema.String;
+        }>>;
+        readonly missingAt: Schema.optionalKey<Schema.Struct<{
+            readonly startedAt: Schema.String;
+            readonly observedAt: Schema.String;
+        }>>;
+    }>>;
+}>;
+export type AsxDataset = typeof Dataset.Type;
+export declare const SnapshotOutcome: Schema.Union<readonly [Schema.Struct<{
+    readonly status: Schema.Literal<"found">;
+    readonly observation: Schema.Struct<{
+        readonly company: Schema.Struct<{
+            readonly raw: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+            readonly ticker: Schema.String;
+            readonly sourceId: Schema.String;
+            readonly companyName: Schema.String;
+            readonly address: Schema.NullOr<Schema.String>;
+            readonly tel: Schema.NullOr<Schema.String>;
+            readonly fax: Schema.NullOr<Schema.String>;
+            readonly website: Schema.NullOr<Schema.String>;
+            readonly description: Schema.NullOr<Schema.String>;
+            readonly issueType: Schema.NullOr<Schema.String>;
+            readonly foreignExempt: Schema.NullOr<Schema.Boolean>;
+            readonly people: Schema.$Array<Schema.Struct<{
+                readonly sourceName: Schema.String;
+                readonly displayName: Schema.String;
+                readonly title: Schema.String;
+                readonly sourceCategory: Schema.Literals<readonly ["directors", "secretaries"]>;
+            }>>;
+        }>;
+        readonly startedAt: Schema.String;
+        readonly observedAt: Schema.String;
+        readonly lastChangedAt: Schema.String;
+    }>;
+    readonly enrichment: Schema.optionalKey<Schema.Struct<{
+        readonly ticker: Schema.String;
+        readonly sourceId: Schema.NonEmptyString;
+        readonly abn: Schema.String;
+        readonly acn: Schema.NullOr<Schema.String>;
+        readonly legalName: Schema.NonEmptyString;
+        readonly identityEvidence: Schema.Struct<{
+            readonly url: Schema.String;
+            readonly sha256: Schema.String;
+            readonly observedAt: Schema.String;
+            readonly kind: Schema.Literals<readonly ["issuer-filing", "issuer-website"]>;
+        }>;
+        readonly abrEvidence: Schema.Struct<{
+            readonly source: Schema.Literals<readonly ["abr-live", "abr-snapshot"]>;
+            readonly observedAt: Schema.String;
+        }>;
+        readonly website: Schema.NullOr<Schema.Struct<{
+            readonly url: Schema.String;
+            readonly evidence: Schema.Struct<{
+                readonly url: Schema.String;
+                readonly sha256: Schema.String;
+                readonly observedAt: Schema.String;
+                readonly kind: Schema.Literals<readonly ["issuer-filing", "issuer-website"]>;
+            }>;
+        }>>;
+    }>>;
+    readonly generation: Schema.String;
+}>, Schema.Struct<{
+    readonly status: Schema.Literal<"missing">;
+    readonly generation: Schema.String;
+}>, Schema.Struct<{
+    readonly status: Schema.Literal<"unavailable">;
+    readonly generation: Schema.String;
+}>]>;
+export type SnapshotOutcome = typeof SnapshotOutcome.Type;
+export interface AsxSnapshot {
+    readonly generation: string;
+    /** Entire company row, including independent source payloads even when ASX details are absent. */
+    readonly record: (ticker: string) => CompanyRecord | null;
+    readonly lookup: (ticker: string, signal?: AbortSignal) => Promise<SnapshotOutcome>;
+    readonly suggest: (query: string, limit?: number) => readonly DirectoryEntry[];
+    readonly findByAbn: (abn: string) => readonly {
+        directory: DirectoryEntry;
+        enrichment: ConfirmedEnrichment;
+    }[];
+    /** Listed companies whose name matches this ABN's entity name under the #385 rules. */
+    readonly findNameMatchesByAbn: (abn: string) => readonly {
+        directory: DirectoryEntry;
+        nameMatch: AbnNameMatch;
+    }[];
+    readonly metadata: () => {
+        directoryObservedAt: string;
+        records: number;
+        availableProfiles: number;
+        confirmedAbns: number;
+        unresolvedAbns: number;
+        confirmedWebsites: number;
+    };
+}
+export declare function decodeDataset(input: unknown): AsxDataset;
+/** Build content-addressed bytes; the host must verify its write before selection. */
+export declare function encodeSnapshot(input: unknown): Promise<{
+    generation: string;
+    text: string;
+}>;
+/** The trusted host pins the expected generation; body content cannot choose it. */
+export declare function openSnapshot(text: string, expectedGeneration: string): Promise<AsxSnapshot>;
+export {};