@nakafa/aksara-contracts 0.27.0

package/dist/quran/identity.js

@@ -0,0 +1,100 @@
+import { Match, Schema } from "effect";
+import { AppLocaleCodeSchema, ENGLISH_APP_LOCALE_CODE, GERMAN_APP_LOCALE_CODE, INDONESIAN_APP_LOCALE_CODE, } from "#contracts/locale";
+/** Official source identities whose bytes are pinned inside Aksara. */
+export const QuranEmbeddedSourceIdSchema = Schema.Literals([
+    "tanzil-text",
+    "tanzil-metadata",
+    "kemenag-names",
+    "bubenheim-names",
+    "quranenc-english",
+    "quranenc-indonesian",
+    "quranenc-german",
+    "quranenc-tafsir",
+]);
+/** Official source identities that Aksara may link to but not republish. */
+export const QuranExternalSourceIdSchema = Schema.Literals([
+    "mokhtasar-english",
+    "mokhtasar-german",
+]);
+/** Exact official Quran source identities in visible attribution order. */
+export const QuranSourceIdSchema = Schema.Literals([
+    ...QuranEmbeddedSourceIdSchema.literals,
+    ...QuranExternalSourceIdSchema.literals,
+]);
+/** Canonical order of every official source supported by the contract. */
+export const QURAN_SOURCE_IDS = QuranSourceIdSchema.literals;
+/** Locale-specific translation field in Quran source provenance. */
+export const QuranTranslationProvenanceScopeSchema = Schema.TemplateLiteral([
+    AppLocaleCodeSchema,
+    "-translation",
+]);
+/** Locale-specific surah-name field in Quran source provenance. */
+export const QuranNameProvenanceScopeSchema = Schema.TemplateLiteral([
+    AppLocaleCodeSchema,
+    "-surah-name",
+]);
+const QURAN_NAME_BY_LOCALE = {
+    [ENGLISH_APP_LOCALE_CODE]: {
+        scope: "en-surah-name",
+        sourceId: "tanzil-metadata",
+    },
+    [GERMAN_APP_LOCALE_CODE]: {
+        scope: "de-surah-name",
+        sourceId: "bubenheim-names",
+    },
+    [INDONESIAN_APP_LOCALE_CODE]: {
+        scope: "id-surah-name",
+        sourceId: "kemenag-names",
+    },
+};
+const QURAN_TRANSLATION_BY_LOCALE = {
+    [ENGLISH_APP_LOCALE_CODE]: {
+        scope: "en-translation",
+        sourceId: "quranenc-english",
+    },
+    [GERMAN_APP_LOCALE_CODE]: {
+        scope: "de-translation",
+        sourceId: "quranenc-german",
+    },
+    [INDONESIAN_APP_LOCALE_CODE]: {
+        scope: "id-translation",
+        sourceId: "quranenc-indonesian",
+    },
+};
+const QURAN_TAFSIR_BY_LOCALE = {
+    [ENGLISH_APP_LOCALE_CODE]: { sourceId: "mokhtasar-english" },
+    [GERMAN_APP_LOCALE_CODE]: { sourceId: "mokhtasar-german" },
+    [INDONESIAN_APP_LOCALE_CODE]: { sourceId: "quranenc-tafsir" },
+};
+/** Resolves the selected surah-name source identity. */
+export function quranNameSourceId(appLocale) {
+    return QURAN_NAME_BY_LOCALE[appLocale].sourceId;
+}
+/** Resolves the selected surah-name provenance scope. */
+export function quranNameProvenanceScope(appLocale) {
+    return QURAN_NAME_BY_LOCALE[appLocale].scope;
+}
+/** Resolves the selected translation source identity. */
+export function quranTranslationSourceId(appLocale) {
+    return QURAN_TRANSLATION_BY_LOCALE[appLocale].sourceId;
+}
+/** Resolves the selected Tafsir source identity. */
+export function quranTafsirSourceId(appLocale) {
+    return QURAN_TAFSIR_BY_LOCALE[appLocale].sourceId;
+}
+/** Resolves the selected translation provenance scope. */
+export function quranTranslationProvenanceScope(appLocale) {
+    return QURAN_TRANSLATION_BY_LOCALE[appLocale].scope;
+}
+/** Resolves a translation provenance scope through the canonical locale map. */
+export function quranTranslationSourceForScope(scope) {
+    return Match.value(scope).pipe(Match.when("en-translation", () => quranTranslationSourceId(ENGLISH_APP_LOCALE_CODE)), Match.when("id-translation", () => quranTranslationSourceId(INDONESIAN_APP_LOCALE_CODE)), Match.when("de-translation", () => quranTranslationSourceId(GERMAN_APP_LOCALE_CODE)), Match.exhaustive);
+}
+/** Resolves a surah-name provenance scope through the canonical locale map. */
+export function quranNameSourceForScope(scope) {
+    return Match.value(scope).pipe(Match.when("en-surah-name", () => quranNameSourceId(ENGLISH_APP_LOCALE_CODE)), Match.when("id-surah-name", () => quranNameSourceId(INDONESIAN_APP_LOCALE_CODE)), Match.when("de-surah-name", () => quranNameSourceId(GERMAN_APP_LOCALE_CODE)), Match.exhaustive);
+}
+/** Selects the signed Arabic and localized translation reading sources. */
+export function quranReadingSourceIds(appLocale) {
+    return ["tanzil-text", quranTranslationSourceId(appLocale)];
+}

package/dist/quran/notes.d.ts

@@ -0,0 +1,56 @@
+import { Effect, Schema } from "effect";
+/** Semantic translation text and its exact source-authored notes. */
+export declare const QuranTranslationDocumentSchema: Schema.Struct<{
+    readonly notes: Schema.$Array<Schema.Struct<{
+        readonly number: Schema.Int;
+        readonly referenceOffset: Schema.Int;
+        readonly text: Schema.String;
+    }>>;
+    readonly segments: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+        readonly kind: Schema.Literal<"text">;
+        readonly offset: Schema.Int;
+        readonly value: Schema.String;
+    }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"note">;
+        readonly number: Schema.Int;
+        readonly offset: Schema.Int;
+    }>]>>;
+}>;
+export type QuranTranslationDocument = typeof QuranTranslationDocumentSchema.Type;
+declare const QuranTranslationNotesError_base: Schema.Class<QuranTranslationNotesError, Schema.TaggedStruct<"QuranTranslationNotesError", {
+    readonly reason: Schema.Literals<readonly ["empty-note", "invalid-marker", "invalid-source", "mismatched-markers"]>;
+}>, import("effect/Cause").YieldableError>;
+/** The translation and note markers do not form one exact projection. */
+export declare class QuranTranslationNotesError extends QuranTranslationNotesError_base {
+}
+declare const QuranTranslationSourceSchema: Schema.Struct<{
+    readonly footnotes: Schema.String;
+    readonly text: Schema.String;
+}>;
+type QuranTranslationSource = typeof QuranTranslationSourceSchema.Type;
+/** Checks that every source marker resolves to one exact non-empty note. */
+export declare function hasConsistentQuranTranslationNotes(source: QuranTranslationSource): boolean;
+/** One verbatim QuranEnc translation with a consistent note relationship. */
+export declare const QuranTranslationSchema: Schema.Struct<{
+    readonly footnotes: Schema.String;
+    readonly text: Schema.String;
+}>;
+export type QuranTranslation = typeof QuranTranslationSchema.Type;
+/** Parses one exact source translation into linked reference-ready semantics. */
+export declare const parseQuranTranslation: (input: unknown) => Effect.Effect<{
+    readonly notes: readonly {
+        readonly number: number;
+        readonly referenceOffset: number;
+        readonly text: string;
+    }[];
+    readonly segments: readonly ({
+        readonly kind: "text";
+        readonly offset: number;
+        readonly value: string;
+    } | {
+        readonly kind: "note";
+        readonly number: number;
+        readonly offset: number;
+    })[];
+}, QuranTranslationNotesError, never>;
+export {};

package/dist/quran/notes.js

@@ -0,0 +1,142 @@
+import { Effect, Schema } from "effect";
+import { QuranMeaningfulTextSchema } from "#contracts/quran/text";
+const QuranTranslationNoteNumberSchema = Schema.Int.pipe(Schema.check(Schema.isGreaterThan(0)));
+const QuranTranslationOffsetSchema = Schema.Int.pipe(Schema.check(Schema.isGreaterThanOrEqualTo(0)));
+const QuranTranslationSegmentSchema = Schema.Union([
+    Schema.Struct({
+        kind: Schema.Literal("text"),
+        offset: QuranTranslationOffsetSchema,
+        value: Schema.String,
+    }),
+    Schema.Struct({
+        kind: Schema.Literal("note"),
+        number: QuranTranslationNoteNumberSchema,
+        offset: QuranTranslationOffsetSchema,
+    }),
+]);
+const QuranTranslationNoteSchema = Schema.Struct({
+    number: QuranTranslationNoteNumberSchema,
+    referenceOffset: QuranTranslationOffsetSchema,
+    text: Schema.String,
+});
+/** Semantic translation text and its exact source-authored notes. */
+export const QuranTranslationDocumentSchema = Schema.Struct({
+    notes: Schema.Array(QuranTranslationNoteSchema),
+    segments: Schema.Array(QuranTranslationSegmentSchema),
+});
+/** The translation and note markers do not form one exact projection. */
+export class QuranTranslationNotesError extends Schema.TaggedError()("QuranTranslationNotesError", {
+    reason: Schema.Literals([
+        "empty-note",
+        "invalid-marker",
+        "invalid-source",
+        "mismatched-markers",
+    ]),
+}) {
+}
+const QuranTranslationSourceSchema = Schema.Struct({
+    footnotes: Schema.String,
+    text: QuranMeaningfulTextSchema,
+});
+/** Reads every numeric marker without treating editorial brackets as notes. */
+function readMarkers(source) {
+    const markers = [];
+    for (const match of source.matchAll(/\[(\d+)\]/gu)) {
+        const rawNumber = match[0].slice(1, -1);
+        const start = match.index;
+        const number = Number(rawNumber);
+        if (rawNumber !== String(number) ||
+            !Schema.is(QuranTranslationNoteNumberSchema)(number)) {
+            return { _tag: "Failure" };
+        }
+        markers.push({ end: start + match[0].length, number, start });
+    }
+    return { _tag: "Success", markers };
+}
+/** Converts the translation body to text and note-reference segments. */
+function segmentTranslation(source, markers) {
+    const segments = [];
+    let start = 0;
+    for (const marker of markers) {
+        if (marker.start > start) {
+            segments.push({
+                kind: "text",
+                offset: start,
+                value: source.slice(start, marker.start),
+            });
+        }
+        segments.push({
+            kind: "note",
+            number: marker.number,
+            offset: marker.start,
+        });
+        start = marker.end;
+    }
+    if (start < source.length || segments.length === 0) {
+        segments.push({ kind: "text", offset: start, value: source.slice(start) });
+    }
+    return segments;
+}
+/** Analyzes one source translation through the canonical note grammar. */
+function analyzeTranslation(source) {
+    const referencesResult = readMarkers(source.text);
+    const definitionsResult = readMarkers(source.footnotes);
+    if (referencesResult._tag === "Failure" ||
+        definitionsResult._tag === "Failure") {
+        return { _tag: "Failure", reason: "invalid-marker" };
+    }
+    const references = referencesResult.markers;
+    const definitions = definitionsResult.markers;
+    const uniqueReferences = references.filter((reference, index) => references.findIndex(({ number }) => number === reference.number) ===
+        index);
+    const noteCandidates = definitions.map((definition, index) => ({
+        definition,
+        referenceOffset: uniqueReferences[index]?.start ?? -1,
+    }));
+    const definitionNumbers = definitions.map(({ number }) => number);
+    const hasDuplicateDefinition = definitionNumbers.some((number, index) => definitionNumbers.indexOf(number) !== index);
+    const hasMismatchedMarkers = hasDuplicateDefinition ||
+        uniqueReferences.length !== definitionNumbers.length ||
+        noteCandidates.some(({ definition, referenceOffset }, index) => referenceOffset < 0 ||
+            definition.number !== uniqueReferences[index]?.number) ||
+        (definitions[0] === undefined
+            ? source.footnotes.trim().length > 0
+            : source.footnotes.slice(0, definitions[0].start).trim().length > 0);
+    if (hasMismatchedMarkers) {
+        return { _tag: "Failure", reason: "mismatched-markers" };
+    }
+    const notes = noteCandidates.map(({ definition, referenceOffset }, index) => ({
+        number: definition.number,
+        referenceOffset,
+        text: source.footnotes
+            .slice(definition.end, definitions[index + 1]?.start)
+            .trim(),
+    }));
+    if (notes.some(({ text }) => text.length === 0)) {
+        return { _tag: "Failure", reason: "empty-note" };
+    }
+    return {
+        _tag: "Success",
+        document: QuranTranslationDocumentSchema.make({
+            notes,
+            segments: segmentTranslation(source.text, references),
+        }),
+    };
+}
+/** Checks that every source marker resolves to one exact non-empty note. */
+export function hasConsistentQuranTranslationNotes(source) {
+    return analyzeTranslation(source)._tag === "Success";
+}
+/** One verbatim QuranEnc translation with a consistent note relationship. */
+export const QuranTranslationSchema = QuranTranslationSourceSchema.pipe(Schema.check(Schema.makeFilter(hasConsistentQuranTranslationNotes, {
+    message: "Quran translation markers must resolve to exact non-empty source notes.",
+})));
+/** Parses one exact source translation into linked reference-ready semantics. */
+export const parseQuranTranslation = Effect.fn("AksaraContracts.parseQuranTranslation")(function* (input) {
+    const source = yield* Schema.decodeUnknownEffect(QuranTranslationSourceSchema)(input, { onExcessProperty: "error" }).pipe(Effect.mapError(() => new QuranTranslationNotesError({ reason: "invalid-source" })));
+    const result = analyzeTranslation(source);
+    if (result._tag === "Failure") {
+        return yield* new QuranTranslationNotesError({ reason: result.reason });
+    }
+    return result.document;
+});

package/dist/quran/provenance.d.ts

@@ -0,0 +1,257 @@
+import { Effect, Schema } from "effect";
+import { type ActiveAppLocaleList } from "#contracts/locale";
+import { type QuranSourceId } from "#contracts/quran/identity";
+/** Complete source-field vocabulary supported by current Quran publication. */
+export declare const QuranProvenanceScopeSchema: Schema.Union<readonly [Schema.Union<readonly [Schema.Literals<readonly ["arabic-text", "metadata"]>, Schema.Literals<readonly ["en-tafsir-access", "de-tafsir-access"]>, Schema.Literal<"id-tafsir">]>, Schema.TemplateLiteral<readonly [Schema.Literals<readonly ["en", "id", "de"]>, "-surah-name"]>, Schema.TemplateLiteral<readonly [Schema.Literals<readonly ["en", "id", "de"]>, "-translation"]>]>;
+export type QuranProvenanceScope = typeof QuranProvenanceScopeSchema.Type;
+/** Derives the exact provenance scope order for one active locale set. */
+export declare function quranProvenanceScopes(activeAppLocales: ActiveAppLocaleList): readonly QuranProvenanceScope[];
+/** Resolves the only official source allowed to prove one provenance scope. */
+export declare function quranSourceForProvenanceScope(scope: QuranProvenanceScope): QuranSourceId;
+/** One reviewed official artifact and its field-level permission decision. */
+export declare const QuranProvenanceRecordSchema: Schema.Struct<{
+    readonly attribution: Schema.Union<readonly [Schema.Struct<{
+        readonly copy: Schema.NonEmptyArray<Schema.Struct<{
+            readonly appLocale: Schema.brand<Schema.Literals<readonly ["en", "id", "de"]>, "@NakafaAI/AksaraAppLocale">;
+            readonly notice: Schema.Trimmed;
+            readonly title: Schema.Trimmed;
+        }>>;
+        readonly publisher: Schema.Trimmed;
+        readonly retrievedAt: Schema.String;
+        readonly sourceUrl: Schema.String;
+        readonly updateUrl: Schema.String;
+        readonly version: Schema.Trimmed;
+        readonly artifact: Schema.Struct<{
+            readonly byteCount: Schema.Int;
+            readonly digest: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+            readonly fileCount: Schema.Int;
+        }>;
+        readonly id: Schema.Literals<readonly ["tanzil-text", "tanzil-metadata", "kemenag-names", "bubenheim-names", "quranenc-english", "quranenc-indonesian", "quranenc-german", "quranenc-tafsir"]>;
+        readonly kind: Schema.Literal<"embedded">;
+        readonly terms: Schema.Struct<{
+            readonly artifact: Schema.Struct<{
+                readonly byteCount: Schema.Int;
+                readonly digest: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+                readonly fileCount: Schema.Int;
+            }>;
+            readonly url: Schema.String;
+        }>;
+    }>, Schema.Struct<{
+        readonly copy: Schema.NonEmptyArray<Schema.Struct<{
+            readonly appLocale: Schema.brand<Schema.Literals<readonly ["en", "id", "de"]>, "@NakafaAI/AksaraAppLocale">;
+            readonly notice: Schema.Trimmed;
+            readonly title: Schema.Trimmed;
+        }>>;
+        readonly publisher: Schema.Trimmed;
+        readonly retrievedAt: Schema.String;
+        readonly sourceUrl: Schema.String;
+        readonly updateUrl: Schema.String;
+        readonly version: Schema.Trimmed;
+        readonly id: Schema.Literals<readonly ["mokhtasar-english", "mokhtasar-german"]>;
+        readonly kind: Schema.Literal<"external">;
+        readonly terms: Schema.Struct<{
+            readonly access: Schema.Literal<"link-only">;
+            readonly url: Schema.String;
+        }>;
+    }>]>;
+    readonly evidence: Schema.Trimmed;
+    readonly scope: Schema.Union<readonly [Schema.Union<readonly [Schema.Literals<readonly ["arabic-text", "metadata"]>, Schema.Literals<readonly ["en-tafsir-access", "de-tafsir-access"]>, Schema.Literal<"id-tafsir">]>, Schema.TemplateLiteral<readonly [Schema.Literals<readonly ["en", "id", "de"]>, "-surah-name"]>, Schema.TemplateLiteral<readonly [Schema.Literals<readonly ["en", "id", "de"]>, "-translation"]>]>;
+    readonly status: Schema.Literals<readonly ["approved", "blocked"]>;
+}>;
+export type QuranProvenanceRecord = typeof QuranProvenanceRecordSchema.Type;
+/** Complete ordered evidence set that gates Quran production publication. */
+export declare const QuranProvenanceManifestSchema: Schema.Struct<{
+    readonly activeAppLocales: Schema.NonEmptyArray<Schema.brand<Schema.Literals<readonly ["en", "id", "de"]>, "@NakafaAI/AksaraAppLocale">>;
+    readonly digest: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+    readonly records: Schema.NonEmptyArray<Schema.Struct<{
+        readonly attribution: Schema.Union<readonly [Schema.Struct<{
+            readonly copy: Schema.NonEmptyArray<Schema.Struct<{
+                readonly appLocale: Schema.brand<Schema.Literals<readonly ["en", "id", "de"]>, "@NakafaAI/AksaraAppLocale">;
+                readonly notice: Schema.Trimmed;
+                readonly title: Schema.Trimmed;
+            }>>;
+            readonly publisher: Schema.Trimmed;
+            readonly retrievedAt: Schema.String;
+            readonly sourceUrl: Schema.String;
+            readonly updateUrl: Schema.String;
+            readonly version: Schema.Trimmed;
+            readonly artifact: Schema.Struct<{
+                readonly byteCount: Schema.Int;
+                readonly digest: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+                readonly fileCount: Schema.Int;
+            }>;
+            readonly id: Schema.Literals<readonly ["tanzil-text", "tanzil-metadata", "kemenag-names", "bubenheim-names", "quranenc-english", "quranenc-indonesian", "quranenc-german", "quranenc-tafsir"]>;
+            readonly kind: Schema.Literal<"embedded">;
+            readonly terms: Schema.Struct<{
+                readonly artifact: Schema.Struct<{
+                    readonly byteCount: Schema.Int;
+                    readonly digest: Schema.brand<Schema.String, "@NakafaAI/AksaraSha256Hash">;
+                    readonly fileCount: Schema.Int;
+                }>;
+                readonly url: Schema.String;
+            }>;
+        }>, Schema.Struct<{
+            readonly copy: Schema.NonEmptyArray<Schema.Struct<{
+                readonly appLocale: Schema.brand<Schema.Literals<readonly ["en", "id", "de"]>, "@NakafaAI/AksaraAppLocale">;
+                readonly notice: Schema.Trimmed;
+                readonly title: Schema.Trimmed;
+            }>>;
+            readonly publisher: Schema.Trimmed;
+            readonly retrievedAt: Schema.String;
+            readonly sourceUrl: Schema.String;
+            readonly updateUrl: Schema.String;
+            readonly version: Schema.Trimmed;
+            readonly id: Schema.Literals<readonly ["mokhtasar-english", "mokhtasar-german"]>;
+            readonly kind: Schema.Literal<"external">;
+            readonly terms: Schema.Struct<{
+                readonly access: Schema.Literal<"link-only">;
+                readonly url: Schema.String;
+            }>;
+        }>]>;
+        readonly evidence: Schema.Trimmed;
+        readonly scope: Schema.Union<readonly [Schema.Union<readonly [Schema.Literals<readonly ["arabic-text", "metadata"]>, Schema.Literals<readonly ["en-tafsir-access", "de-tafsir-access"]>, Schema.Literal<"id-tafsir">]>, Schema.TemplateLiteral<readonly [Schema.Literals<readonly ["en", "id", "de"]>, "-surah-name"]>, Schema.TemplateLiteral<readonly [Schema.Literals<readonly ["en", "id", "de"]>, "-translation"]>]>;
+        readonly status: Schema.Literals<readonly ["approved", "blocked"]>;
+    }>>;
+    readonly status: Schema.Literals<readonly ["approved", "blocked"]>;
+}>;
+export type QuranProvenanceManifest = typeof QuranProvenanceManifestSchema.Type;
+declare const QuranProvenanceCoverageError_base: Schema.Class<QuranProvenanceCoverageError, Schema.TaggedStruct<"QuranProvenanceCoverageError", {
+    readonly actualScopes: Schema.$Array<Schema.Union<readonly [Schema.Union<readonly [Schema.Literals<readonly ["arabic-text", "metadata"]>, Schema.Literals<readonly ["en-tafsir-access", "de-tafsir-access"]>, Schema.Literal<"id-tafsir">]>, Schema.TemplateLiteral<readonly [Schema.Literals<readonly ["en", "id", "de"]>, "-surah-name"]>, Schema.TemplateLiteral<readonly [Schema.Literals<readonly ["en", "id", "de"]>, "-translation"]>]>>;
+}>, import("effect/Cause").YieldableError>;
+/** Quran provenance omitted or misordered an active-locale scope. */
+export declare class QuranProvenanceCoverageError extends QuranProvenanceCoverageError_base {
+}
+declare const QuranProvenanceHashError_base: Schema.Class<QuranProvenanceHashError, Schema.TaggedStruct<"QuranProvenanceHashError", {}>, import("effect/Cause").YieldableError>;
+/** Node could not compute the deterministic provenance digest. */
+export declare class QuranProvenanceHashError extends QuranProvenanceHashError_base {
+}
+/** Produces stable JSON for one reviewed Quran provenance record. */
+export declare function canonicalizeQuranProvenance(record: QuranProvenanceRecord): string;
+/** Digests exact ordered provenance records under their active locale set. */
+export declare const hashQuranProvenance: (input: {
+    readonly activeAppLocales: ActiveAppLocaleList;
+    readonly records: readonly QuranProvenanceRecord[];
+}) => Effect.Effect<string & import("effect/Brand").Brand<"@NakafaAI/AksaraSha256Hash">, QuranProvenanceHashError, never>;
+/** Builds a snapshot provenance gate from exact reviewed source records. */
+export declare const makeQuranProvenanceManifest: (input: {
+    readonly activeAppLocales: ActiveAppLocaleList;
+    readonly records: readonly QuranProvenanceRecord[];
+}) => Effect.Effect<{
+    readonly activeAppLocales: readonly [("de" | "en" | "id") & import("effect/Brand").Brand<"@NakafaAI/AksaraAppLocale">, ...(("de" | "en" | "id") & import("effect/Brand").Brand<"@NakafaAI/AksaraAppLocale">)[]];
+    readonly digest: string & import("effect/Brand").Brand<"@NakafaAI/AksaraSha256Hash">;
+    readonly records: readonly [{
+        readonly attribution: {
+            readonly copy: readonly [{
+                readonly appLocale: ("de" | "en" | "id") & import("effect/Brand").Brand<"@NakafaAI/AksaraAppLocale">;
+                readonly notice: string;
+                readonly title: string;
+            }, ...{
+                readonly appLocale: ("de" | "en" | "id") & import("effect/Brand").Brand<"@NakafaAI/AksaraAppLocale">;
+                readonly notice: string;
+                readonly title: string;
+            }[]];
+            readonly publisher: string;
+            readonly retrievedAt: string;
+            readonly sourceUrl: string;
+            readonly updateUrl: string;
+            readonly version: string;
+            readonly artifact: {
+                readonly byteCount: number;
+                readonly digest: string & import("effect/Brand").Brand<"@NakafaAI/AksaraSha256Hash">;
+                readonly fileCount: number;
+            };
+            readonly id: "bubenheim-names" | "kemenag-names" | "quranenc-english" | "quranenc-german" | "quranenc-indonesian" | "quranenc-tafsir" | "tanzil-metadata" | "tanzil-text";
+            readonly kind: "embedded";
+            readonly terms: {
+                readonly artifact: {
+                    readonly byteCount: number;
+                    readonly digest: string & import("effect/Brand").Brand<"@NakafaAI/AksaraSha256Hash">;
+                    readonly fileCount: number;
+                };
+                readonly url: string;
+            };
+        } | {
+            readonly copy: readonly [{
+                readonly appLocale: ("de" | "en" | "id") & import("effect/Brand").Brand<"@NakafaAI/AksaraAppLocale">;
+                readonly notice: string;
+                readonly title: string;
+            }, ...{
+                readonly appLocale: ("de" | "en" | "id") & import("effect/Brand").Brand<"@NakafaAI/AksaraAppLocale">;
+                readonly notice: string;
+                readonly title: string;
+            }[]];
+            readonly publisher: string;
+            readonly retrievedAt: string;
+            readonly sourceUrl: string;
+            readonly updateUrl: string;
+            readonly version: string;
+            readonly id: "mokhtasar-english" | "mokhtasar-german";
+            readonly kind: "external";
+            readonly terms: {
+                readonly access: "link-only";
+                readonly url: string;
+            };
+        };
+        readonly evidence: string;
+        readonly scope: "arabic-text" | "de-surah-name" | "de-tafsir-access" | "de-translation" | "en-surah-name" | "en-tafsir-access" | "en-translation" | "id-surah-name" | "id-tafsir" | "id-translation" | "metadata";
+        readonly status: "approved" | "blocked";
+    }, ...{
+        readonly attribution: {
+            readonly copy: readonly [{
+                readonly appLocale: ("de" | "en" | "id") & import("effect/Brand").Brand<"@NakafaAI/AksaraAppLocale">;
+                readonly notice: string;
+                readonly title: string;
+            }, ...{
+                readonly appLocale: ("de" | "en" | "id") & import("effect/Brand").Brand<"@NakafaAI/AksaraAppLocale">;
+                readonly notice: string;
+                readonly title: string;
+            }[]];
+            readonly publisher: string;
+            readonly retrievedAt: string;
+            readonly sourceUrl: string;
+            readonly updateUrl: string;
+            readonly version: string;
+            readonly artifact: {
+                readonly byteCount: number;
+                readonly digest: string & import("effect/Brand").Brand<"@NakafaAI/AksaraSha256Hash">;
+                readonly fileCount: number;
+            };
+            readonly id: "bubenheim-names" | "kemenag-names" | "quranenc-english" | "quranenc-german" | "quranenc-indonesian" | "quranenc-tafsir" | "tanzil-metadata" | "tanzil-text";
+            readonly kind: "embedded";
+            readonly terms: {
+                readonly artifact: {
+                    readonly byteCount: number;
+                    readonly digest: string & import("effect/Brand").Brand<"@NakafaAI/AksaraSha256Hash">;
+                    readonly fileCount: number;
+                };
+                readonly url: string;
+            };
+        } | {
+            readonly copy: readonly [{
+                readonly appLocale: ("de" | "en" | "id") & import("effect/Brand").Brand<"@NakafaAI/AksaraAppLocale">;
+                readonly notice: string;
+                readonly title: string;
+            }, ...{
+                readonly appLocale: ("de" | "en" | "id") & import("effect/Brand").Brand<"@NakafaAI/AksaraAppLocale">;
+                readonly notice: string;
+                readonly title: string;
+            }[]];
+            readonly publisher: string;
+            readonly retrievedAt: string;
+            readonly sourceUrl: string;
+            readonly updateUrl: string;
+            readonly version: string;
+            readonly id: "mokhtasar-english" | "mokhtasar-german";
+            readonly kind: "external";
+            readonly terms: {
+                readonly access: "link-only";
+                readonly url: string;
+            };
+        };
+        readonly evidence: string;
+        readonly scope: "arabic-text" | "de-surah-name" | "de-tafsir-access" | "de-translation" | "en-surah-name" | "en-tafsir-access" | "en-translation" | "id-surah-name" | "id-tafsir" | "id-translation" | "metadata";
+        readonly status: "approved" | "blocked";
+    }[]];
+    readonly status: "approved" | "blocked";
+}, QuranProvenanceCoverageError | QuranProvenanceHashError, never>;
+export {};