@comms-id/asx 0.4.1 → 1.0.0

package/dist/directory-search.js

@@ -0,0 +1,33 @@
+import { failure } from "./model.js";
+export function suggestDirectory(entries, query, limit) {
+    if (typeof query !== "string" ||
+        query.length > 200 ||
+        !Number.isInteger(limit) ||
+        limit < 1 ||
+        limit > 10)
+        throw failure("INVALID_INPUT");
+    const normalized = query.trim().toUpperCase();
+    if (normalized.length < 2)
+        return [];
+    const tokens = normalized.split(/\s+/);
+    return entries
+        .map((directory) => {
+        const name = directory.companyName.toUpperCase();
+        const score = directory.ticker === normalized
+            ? 0
+            : directory.ticker.startsWith(normalized)
+                ? 1
+                : name.startsWith(normalized)
+                    ? 2
+                    : tokens.every((token) => name.includes(token))
+                        ? 3
+                        : 4;
+        return { directory, score };
+    })
+        .filter(({ score }) => score < 4)
+        .sort((a, b) => a.score - b.score ||
+        a.directory.companyName.localeCompare(b.directory.companyName, "en") ||
+        a.directory.ticker.localeCompare(b.directory.ticker, "en"))
+        .slice(0, limit)
+        .map(({ directory }) => structuredClone(directory));
+}

package/dist/enrichment.d.ts

@@ -0,0 +1,75 @@
+import { Schema } from "effect";
+import { Company } from "./model.js";
+export declare function validAbn(abn: string): boolean;
+export declare const Evidence: Schema.Struct<{
+    readonly url: Schema.String;
+    readonly sha256: Schema.String;
+    readonly observedAt: Schema.String;
+    readonly kind: Schema.Literals<readonly ["issuer-filing", "issuer-website"]>;
+}>;
+export interface Evidence extends Schema.Schema.Type<typeof Evidence> {
+}
+export declare const ConfirmedEnrichment: 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"]>;
+        }>;
+    }>>;
+}>;
+export interface ConfirmedEnrichment extends Schema.Schema.Type<typeof ConfirmedEnrichment> {
+}
+export declare const EnrichmentResult: Schema.Union<readonly [Schema.Struct<{
+    readonly status: Schema.Literal<"confirmed">;
+    readonly enrichment: 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"]>;
+            }>;
+        }>>;
+    }>;
+}>, Schema.Struct<{
+    readonly status: Schema.Literal<"unresolved">;
+    readonly reason: Schema.Literals<readonly ["NO_EVIDENCE", "AMBIGUOUS", "INVALID_EVIDENCE", "IDENTITY_MISMATCH"]>;
+}>]>;
+export type EnrichmentResult = typeof EnrichmentResult.Type;
+/** Inputs are accepted primary-source observations from trusted collectors, never public request data. */
+export declare function confirmEnrichment(companyInput: unknown, issuerCandidates: unknown, abrInput: unknown): EnrichmentResult;
+export declare function validEnrichment(value: ConfirmedEnrichment, company: Company): boolean;

package/dist/enrichment.js

@@ -0,0 +1,114 @@
+import { Result, Schema } from "effect";
+import { Company, isTimestamp, Timestamp, Ticker } from "./model.js";
+// ABR's published modulus-89 rule; checksum validity alone never proves issuer identity.
+export function validAbn(abn) {
+    if (!/^\d{11}$/.test(abn))
+        return false;
+    const weights = [10, 1, 3, 5, 7, 9, 11, 13, 15, 17, 19];
+    return (Array.from(abn).reduce((sum, digit, index) => sum + (Number(digit) - (index === 0 ? 1 : 0)) * weights[index], 0) %
+        89 ===
+        0);
+}
+const ABN = Schema.String.check(Schema.makeFilter(validAbn));
+const ACN = Schema.NullOr(Schema.String.check(Schema.isPattern(/^\d{9}$/)));
+const HttpsUrl = Schema.String.check(Schema.makeFilter((value) => {
+    try {
+        const url = new URL(value);
+        return (url.protocol === "https:" &&
+            !url.username &&
+            !url.password &&
+            !!url.hostname &&
+            value.length <= 2048);
+    }
+    catch {
+        return false;
+    }
+}));
+export const Evidence = Schema.Struct({
+    url: HttpsUrl,
+    sha256: Schema.String.check(Schema.isPattern(/^[a-f0-9]{64}$/)),
+    observedAt: Timestamp,
+    kind: Schema.Literals(["issuer-filing", "issuer-website"]),
+});
+export const ConfirmedEnrichment = Schema.Struct({
+    ticker: Ticker,
+    sourceId: Schema.NonEmptyString,
+    abn: ABN,
+    acn: ACN,
+    legalName: Schema.NonEmptyString,
+    identityEvidence: Evidence,
+    abrEvidence: Schema.Struct({
+        source: Schema.Literals(["abr-live", "abr-snapshot"]),
+        observedAt: Timestamp,
+    }),
+    website: Schema.NullOr(Schema.Struct({ url: HttpsUrl, evidence: Evidence })),
+});
+const IssuerEvidence = Schema.Struct({
+    ticker: Ticker,
+    sourceId: Schema.NonEmptyString,
+    issuerName: Schema.NonEmptyString,
+    abn: ABN,
+    acn: ACN,
+    evidence: Evidence,
+    website: Schema.NullOr(Schema.Struct({ url: HttpsUrl, evidence: Evidence })),
+});
+const AbrEvidence = Schema.Struct({
+    abn: ABN,
+    acn: ACN,
+    legalName: Schema.NonEmptyString,
+    source: Schema.Literals(["abr-live", "abr-snapshot"]),
+    observedAt: Timestamp,
+});
+export const EnrichmentResult = Schema.Union([
+    Schema.Struct({ status: Schema.Literal("confirmed"), enrichment: ConfirmedEnrichment }),
+    Schema.Struct({
+        status: Schema.Literal("unresolved"),
+        reason: Schema.Literals(["NO_EVIDENCE", "AMBIGUOUS", "INVALID_EVIDENCE", "IDENTITY_MISMATCH"]),
+    }),
+]);
+const nameKey = (value) => value.trim().toUpperCase().replace(/\s+/g, " ");
+/** Inputs are accepted primary-source observations from trusted collectors, never public request data. */
+export function confirmEnrichment(companyInput, issuerCandidates, abrInput) {
+    const company = Schema.decodeUnknownResult(Company)(companyInput);
+    const candidates = Schema.decodeUnknownResult(Schema.Array(IssuerEvidence))(issuerCandidates);
+    const abr = Schema.decodeUnknownResult(AbrEvidence)(abrInput);
+    if (Result.isFailure(company) || Result.isFailure(candidates) || Result.isFailure(abr))
+        return { status: "unresolved", reason: "INVALID_EVIDENCE" };
+    if (candidates.success.length === 0)
+        return { status: "unresolved", reason: "NO_EVIDENCE" };
+    if (candidates.success.length !== 1)
+        return { status: "unresolved", reason: "AMBIGUOUS" };
+    const issuer = candidates.success[0];
+    if (!isTimestamp(issuer.evidence.observedAt) ||
+        !isTimestamp(abr.success.observedAt) ||
+        (issuer.website && !isTimestamp(issuer.website.evidence.observedAt)))
+        return { status: "unresolved", reason: "INVALID_EVIDENCE" };
+    if (issuer.sourceId !== company.success.sourceId ||
+        issuer.ticker !== company.success.ticker ||
+        nameKey(issuer.issuerName) !== nameKey(company.success.companyName) ||
+        nameKey(issuer.issuerName) !== nameKey(abr.success.legalName) ||
+        issuer.abn !== abr.success.abn ||
+        (issuer.acn !== null && issuer.acn !== abr.success.acn))
+        return { status: "unresolved", reason: "IDENTITY_MISMATCH" };
+    return {
+        status: "confirmed",
+        enrichment: {
+            ticker: issuer.ticker,
+            sourceId: issuer.sourceId,
+            abn: issuer.abn,
+            acn: abr.success.acn,
+            legalName: abr.success.legalName,
+            identityEvidence: issuer.evidence,
+            abrEvidence: { source: abr.success.source, observedAt: abr.success.observedAt },
+            website: issuer.website,
+        },
+    };
+}
+export function validEnrichment(value, company) {
+    return (value.sourceId === company.sourceId &&
+        value.ticker === company.ticker &&
+        nameKey(value.legalName) === nameKey(company.companyName) &&
+        isTimestamp(value.identityEvidence.observedAt) &&
+        isTimestamp(value.abrEvidence.observedAt) &&
+        (value.website === null || isTimestamp(value.website.evidence.observedAt)));
+}

package/dist/generated/fixtures.js

@@ -2,7 +2,7 @@
 // Every reply is the example in the contract.
 /** LOCAL FIXTURES: one canned reply for each operation path. Fake data. */
 export const fixtures = {
-    "/asx/v1/lookup": {
+    "/asx/v2/lookup": {
         "status": "found",
         "source": "live",
         "observation": {
@@ -45,7 +45,7 @@ export const fixtures = {
             "lastChangedAt": "2026-10-03T01:29:55.678Z"
         }
     },
-    "/asx/v1/suggest": {
+    "/asx/v2/suggest": {
         "source": "live",
         "directoryObservedAt": "2026-10-03T00:00:00.000Z",
         "suggestions": []

package/dist/generated/operations.js

@@ -4,7 +4,7 @@ export const operations = {
     lookup: {
         name: "lookup",
         method: "POST",
-        path: "/asx/v1/lookup",
+        path: "/asx/v2/lookup",
         safeToRetry: true,
         request: {
             "t": "obj",
@@ -452,7 +452,7 @@ export const operations = {
                                 "abn": {
                                     "t": "str"
                                 },
-                                "acn": {
+                                "asicNumber": {
                                     "t": "any_of",
                                     "of": [
                                         {
@@ -464,6 +464,24 @@ export const operations = {
                                         }
                                     ]
                                 },
+                                "asicNumberType": {
+                                    "t": "any_of",
+                                    "of": [
+                                        {
+                                            "t": "str",
+                                            "values": [
+                                                "ACN",
+                                                "ARBN",
+                                                "ARSN",
+                                                "ARFN",
+                                                "undetermined"
+                                            ]
+                                        },
+                                        {
+                                            "t": "null"
+                                        }
+                                    ]
+                                },
                                 "legalName": {
                                     "t": "str",
                                     "min": 1
@@ -575,7 +593,8 @@ export const operations = {
                                 "ticker",
                                 "sourceId",
                                 "abn",
-                                "acn",
+                                "asicNumber",
+                                "asicNumberType",
                                 "legalName",
                                 "identityEvidence",
                                 "abrEvidence",
@@ -650,7 +669,7 @@ export const operations = {
     suggest: {
         name: "suggest",
         method: "POST",
-        path: "/asx/v1/suggest",
+        path: "/asx/v2/suggest",
         safeToRetry: true,
         request: {
             "t": "obj",

package/dist/generated/types.d.ts

@@ -70,7 +70,8 @@ export type LookupResponse = {
         readonly ticker: string;
         readonly sourceId: string;
         readonly abn: string;
-        readonly acn: string | null;
+        readonly asicNumber: string | null;
+        readonly asicNumberType: "ACN" | "ARBN" | "ARSN" | "ARFN" | "undetermined" | null;
         readonly legalName: string;
         readonly identityEvidence: {
             readonly url: string;

package/dist/http.d.ts

@@ -0,0 +1 @@
+export declare function boundedText(response: Response, limit: number, signal: AbortSignal): Promise<string>;

package/dist/http.js

@@ -0,0 +1,49 @@
+import { failure } from "./model.js";
+export async function boundedText(response, limit, signal) {
+    if (!response.body)
+        throw failure("PARSE_FAILED");
+    const reader = response.body.getReader();
+    let length = 0;
+    let body = "";
+    const decoder = new TextDecoder("utf-8", { fatal: true, ignoreBOM: false });
+    const decode = (bytes) => {
+        try {
+            return decoder.decode(bytes, { stream: bytes !== undefined });
+        }
+        catch {
+            throw failure("PARSE_FAILED");
+        }
+    };
+    const abort = () => {
+        void reader.cancel().catch(() => undefined);
+    };
+    signal.addEventListener("abort", abort, { once: true });
+    try {
+        while (true) {
+            if (signal.aborted)
+                throw failure("CANCELLED");
+            const chunk = await reader.read();
+            if (chunk.done)
+                break;
+            const bytes = chunk.value;
+            if (!(bytes instanceof Uint8Array))
+                throw failure("PARSE_FAILED");
+            length += bytes.byteLength;
+            if (length > limit)
+                throw failure("PARSE_FAILED");
+            body += decode(bytes);
+        }
+        if (signal.aborted)
+            throw failure("CANCELLED");
+        return body + decode();
+    }
+    finally {
+        signal.removeEventListener("abort", abort);
+        try {
+            await reader.cancel();
+        }
+        finally {
+            reader.releaseLock();
+        }
+    }
+}

package/dist/live.d.ts

@@ -0,0 +1,56 @@
+import { Schema } from "effect";
+import { type DirectoryEntry } from "./model.js";
+export interface AsxLiveConfig {
+    /** Host transport owns network routing; must honour AbortSignal. */
+    readonly fetch?: typeof globalThis.fetch;
+    readonly timeoutMs?: number;
+}
+/** No persistence, source composition, background work or network call at construction. */
+export declare function createAsxLive(config?: AsxLiveConfig): {
+    source: (input: string, signal?: AbortSignal) => Promise<import("./source-record.js").SourceObservation>;
+    lookup: (ticker: string, signal?: AbortSignal) => Promise<{
+        readonly status: "found";
+        readonly observation: {
+            readonly company: {
+                readonly raw?: {
+                    readonly [x: string]: Schema.Json;
+                } | undefined;
+                readonly ticker: string;
+                readonly sourceId: string;
+                readonly companyName: string;
+                readonly address: string | null;
+                readonly tel: string | null;
+                readonly fax: string | null;
+                readonly website: string | null;
+                readonly description: string | null;
+                readonly issueType: string | null;
+                readonly foreignExempt: boolean | null;
+                readonly people: readonly {
+                    readonly sourceName: string;
+                    readonly displayName: string;
+                    readonly title: string;
+                    readonly sourceCategory: "directors" | "secretaries";
+                }[];
+            };
+            readonly startedAt: string;
+            readonly observedAt: string;
+            readonly lastChangedAt: string;
+        };
+    } | {
+        readonly status: "missing";
+        readonly startedAt: string;
+        readonly observedAt: string;
+        readonly raw?: {
+            readonly [x: string]: Schema.Json;
+        } | undefined;
+    }>;
+    directory: (signal?: AbortSignal) => Promise<{
+        entries: readonly DirectoryEntry[];
+        observedAt: string;
+    }>;
+    suggest: (query: string, limit?: number, signal?: AbortSignal) => Promise<{
+        source: "live";
+        directoryObservedAt: string;
+        suggestions: readonly DirectoryEntry[];
+    }>;
+};

package/dist/live.js

@@ -0,0 +1,129 @@
+import { suggestDirectory } from "./directory-search.js";
+import { Effect, Result, Schema } from "effect";
+import { boundedText } from "./http.js";
+import { failure, Failure } from "./model.js";
+import { normalizeTicker, parseCompany, parseDirectory } from "./parse.js";
+import { ASX_COMPANY_BASE, asxSourceObservation } from "./source-record.js";
+const BASE = ASX_COMPANY_BASE;
+const Missing = Schema.Struct({
+    error: Schema.Struct({
+        code: Schema.Literal(400),
+        message: Schema.Literal("Bad Request: Symbol not found"),
+    }),
+});
+function parseJson(text) {
+    try {
+        return JSON.parse(text);
+    }
+    catch {
+        throw failure("PARSE_FAILED");
+    }
+}
+const request = Effect.fn("ASX.http")(function* (transport, path, limit) {
+    return yield* Effect.tryPromise({
+        try: async (signal) => {
+            const response = await transport(`${BASE}${path}`, {
+                signal,
+                redirect: "manual",
+                headers: { Accept: path === "directory/file" ? "text/csv" : "application/json" },
+            });
+            if (response.status === 401 || response.status === 403) {
+                await response.body?.cancel();
+                throw failure("ACCESS_DENIED");
+            }
+            if (response.status === 429) {
+                await response.body?.cancel();
+                throw failure("RATE_LIMITED");
+            }
+            if (response.status >= 500 || response.status === 408) {
+                await response.body?.cancel();
+                throw failure("UPSTREAM_UNAVAILABLE");
+            }
+            if (!response.ok && response.status !== 400) {
+                await response.body?.cancel();
+                throw failure("UPSTREAM_REJECTED");
+            }
+            const body = await boundedText(response, response.ok ? limit : 4096, signal);
+            return { status: response.status, body };
+        },
+        catch: (error) => Schema.is(Failure)(error) ? failure(error.code) : failure("TRANSPORT_FAILED"),
+    });
+});
+function run(program, timeoutMs, signal) {
+    return Effect.runPromise(Effect.result(program.pipe(Effect.timeoutOrElse({
+        duration: timeoutMs,
+        orElse: () => Effect.fail(failure("TIMEOUT")),
+    }))), { signal })
+        .then((result) => {
+        if (Result.isFailure(result))
+            throw result.failure;
+        return result.success;
+    })
+        .catch((error) => {
+        if (signal?.aborted)
+            throw failure("CANCELLED");
+        throw Schema.is(Failure)(error) ? failure(error.code) : failure("INTERNAL_ERROR");
+    });
+}
+/** No persistence, source composition, background work or network call at construction. */
+export function createAsxLive(config = {}) {
+    const timeoutMs = config.timeoutMs ?? 3000;
+    if (!Number.isInteger(timeoutMs) || timeoutMs < 1 || timeoutMs > 60_000)
+        throw failure("CONFIGURATION_ERROR");
+    const transport = config.fetch ?? globalThis.fetch;
+    const lookup = Effect.fn("ASX.profile")(function* (input) {
+        const ticker = yield* Effect.try({
+            try: () => normalizeTicker(input),
+            catch: () => failure("INVALID_INPUT"),
+        });
+        const startedAt = new Date().toISOString();
+        const response = yield* request(transport, `${ticker}/about`, 1024 * 1024);
+        const payload = yield* Effect.try({
+            try: () => parseJson(response.body),
+            catch: () => failure("PARSE_FAILED"),
+        });
+        const observedAt = new Date().toISOString();
+        if (response.status === 400) {
+            if (Schema.is(Missing)(payload) && Schema.is(Schema.JsonObject)(payload))
+                return { status: "missing", startedAt, observedAt, raw: structuredClone(payload) };
+            return yield* Effect.fail(failure("UPSTREAM_REJECTED"));
+        }
+        const company = yield* Effect.try({
+            try: () => parseCompany(ticker, payload),
+            catch: (error) => (Schema.is(Failure)(error) ? failure(error.code) : failure("PARSE_FAILED")),
+        });
+        return {
+            status: "found",
+            observation: { company, startedAt, observedAt, lastChangedAt: observedAt },
+        };
+    });
+    const directory = Effect.fn("ASX.directory")(function* () {
+        const response = yield* request(transport, "directory/file", 4 * 1024 * 1024);
+        if (response.status !== 200)
+            return yield* Effect.fail(failure("UPSTREAM_REJECTED"));
+        const entries = yield* Effect.try({
+            try: () => parseDirectory(response.body),
+            catch: () => failure("PARSE_FAILED"),
+        });
+        return { entries, observedAt: new Date().toISOString() };
+    });
+    return {
+        source: async (input, signal) => {
+            const ticker = normalizeTicker(input);
+            const result = await run(lookup(ticker), timeoutMs, signal);
+            return asxSourceObservation(ticker, result);
+        },
+        lookup: (ticker, signal) => run(lookup(ticker), timeoutMs, signal),
+        directory: (signal) => run(directory(), timeoutMs, signal),
+        suggest: async (query, limit = 8, signal) => {
+            // Validate before acquiring the directory.
+            suggestDirectory([], query, limit);
+            const value = await run(directory(), timeoutMs, signal);
+            return {
+                source: "live",
+                directoryObservedAt: value.observedAt,
+                suggestions: suggestDirectory(value.entries, query, limit),
+            };
+        },
+    };
+}

package/dist/model.d.ts

@@ -0,0 +1,112 @@
+import { Schema } from "effect";
+export declare const Ticker: Schema.String;
+export declare const Person: Schema.Struct<{
+    readonly sourceName: Schema.String;
+    readonly displayName: Schema.String;
+    readonly title: Schema.String;
+    readonly sourceCategory: Schema.Literals<readonly ["directors", "secretaries"]>;
+}>;
+export interface Person extends Schema.Schema.Type<typeof Person> {
+}
+export declare const Company: Schema.Struct<{
+    /** Complete public ASX profile response, including fields unknown to this package version. */
+    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"]>;
+    }>>;
+}>;
+export interface Company extends Schema.Schema.Type<typeof Company> {
+}
+export declare const DirectoryEntry: 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>;
+}>;
+export interface DirectoryEntry extends Schema.Schema.Type<typeof DirectoryEntry> {
+}
+export declare const Failure: Schema.Struct<{
+    readonly _tag: Schema.Literal<"AsxError">;
+    readonly code: Schema.Literals<readonly ["INVALID_INPUT", "PARSE_FAILED", "SOURCE_MISMATCH", "TRANSPORT_FAILED", "TIMEOUT", "RATE_LIMITED", "UPSTREAM_UNAVAILABLE", "CONFIGURATION_ERROR", "SNAPSHOT_UNAVAILABLE", "CANCELLED", "INTERNAL_ERROR", "ACCESS_DENIED", "UPSTREAM_REJECTED", "PERSISTENCE_FAILED", "PUBLICATION_CONFLICT", "COVERAGE_REJECTED"]>;
+}>;
+export type AsxError = typeof Failure.Type;
+export declare const failure: (code: AsxError["code"]) => AsxError;
+export declare const isFallbackEligible: (code: AsxError["code"]) => boolean;
+export declare const Timestamp: Schema.String;
+export declare const Observation: Schema.Struct<{
+    readonly company: Schema.Struct<{
+        /** Complete public ASX profile response, including fields unknown to this package version. */
+        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;
+}>;
+export interface Observation extends Schema.Schema.Type<typeof Observation> {
+}
+export declare const LiveOutcome: Schema.Union<readonly [Schema.Struct<{
+    readonly status: Schema.Literal<"found">;
+    readonly observation: Schema.Struct<{
+        readonly company: Schema.Struct<{
+            /** Complete public ASX profile response, including fields unknown to this package version. */
+            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;
+    }>;
+}>, Schema.Struct<{
+    readonly status: Schema.Literal<"missing">;
+    readonly startedAt: Schema.String;
+    readonly observedAt: Schema.String;
+    readonly raw: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+}>]>;
+export type LiveOutcome = typeof LiveOutcome.Type;
+export declare function isTimestamp(value: string): boolean;
+export declare function validObservation(value: Observation): boolean;