react-semaphor 0.1.504 → 0.1.506

package/dist/types/shared/format-utils/matrix-continuation.d.ts

@@ -0,0 +1,195 @@
+import { z } from 'zod';
+/** Transport budget, independent of total export bytes and analytical tile budgets. */
+export declare const MATRIX_EXPORT_TRANSFER_BYTES: number;
+export declare const matrixExportDeadlineSchema: z.ZodNumber;
+export declare function parseMatrixAttemptKey(jobId: string, key: string): {
+    attemptId: string;
+    filename: string;
+};
+export declare function matrixAttemptKey(jobId: string, attemptId: string, filename: string): string;
+export declare const matrixBatchInputSchema: z.ZodObject<{
+    acquisition: z.ZodLiteral<"continuation">;
+    jobId: z.ZodString;
+    sequence: z.ZodEffects<z.ZodNumber, number, number>;
+    deadlineAt: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    sequence: number;
+    acquisition: "continuation";
+    jobId: string;
+    deadlineAt: number;
+}, {
+    sequence: number;
+    acquisition: "continuation";
+    jobId: string;
+    deadlineAt: number;
+}>;
+export type MatrixBatchInput = z.infer<typeof matrixBatchInputSchema>;
+export type MatrixBatchResult = {
+    acquisition: 'continuation';
+    sequence: number;
+    done: boolean;
+    deadlineAt: number;
+};
+export declare const matrixBatchResponseSchema: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
+    kind: z.ZodLiteral<"work">;
+    sequence: z.ZodEffects<z.ZodNumber, number, number>;
+    checkpointKey: z.ZodString;
+    objects: z.ZodArray<z.ZodEffects<z.ZodObject<{
+        key: z.ZodString;
+        content: z.ZodString;
+        contentType: z.ZodEnum<["text/csv", "application/json"]>;
+        encoding: z.ZodOptional<z.ZodLiteral<"gzip-base64">>;
+    }, "strip", z.ZodTypeAny, {
+        key: string;
+        content: string;
+        contentType: "text/csv" | "application/json";
+        encoding?: "gzip-base64" | undefined;
+    }, {
+        key: string;
+        content: string;
+        contentType: "text/csv" | "application/json";
+        encoding?: "gzip-base64" | undefined;
+    }>, {
+        key: string;
+        content: string;
+        contentType: "text/csv" | "application/json";
+        encoding?: "gzip-base64" | undefined;
+    }, {
+        key: string;
+        content: string;
+        contentType: "text/csv" | "application/json";
+        encoding?: "gzip-base64" | undefined;
+    }>, "many">;
+    deadlineAt: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    kind: "work";
+    sequence: number;
+    deadlineAt: number;
+    checkpointKey: string;
+    objects: {
+        key: string;
+        content: string;
+        contentType: "text/csv" | "application/json";
+        encoding?: "gzip-base64" | undefined;
+    }[];
+}, {
+    kind: "work";
+    sequence: number;
+    deadlineAt: number;
+    checkpointKey: string;
+    objects: {
+        key: string;
+        content: string;
+        contentType: "text/csv" | "application/json";
+        encoding?: "gzip-base64" | undefined;
+    }[];
+}>, z.ZodObject<{
+    kind: z.ZodLiteral<"committed">;
+    sequence: z.ZodEffects<z.ZodNumber, number, number>;
+    done: z.ZodBoolean;
+    deadlineAt: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    kind: "committed";
+    sequence: number;
+    deadlineAt: number;
+    done: boolean;
+}, {
+    kind: "committed";
+    sequence: number;
+    deadlineAt: number;
+    done: boolean;
+}>]>;
+/** Count the complete JSON envelope in UTF-8, including escaping and transport fields. */
+export declare function assertMatrixBatchResponseSize(value: unknown): void;
+/** Validate transport plus job binding once, before upload or publication. */
+export declare function parseMatrixBatchResponse(value: unknown, input: MatrixBatchInput): {
+    kind: "work";
+    sequence: number;
+    deadlineAt: number;
+    checkpointKey: string;
+    objects: {
+        key: string;
+        content: string;
+        contentType: "text/csv" | "application/json";
+        encoding?: "gzip-base64" | undefined;
+    }[];
+} | {
+    kind: "committed";
+    sequence: number;
+    deadlineAt: number;
+    done: boolean;
+};
+export declare const matrixManifestSchema: z.ZodEffects<z.ZodObject<{
+    acquisition: z.ZodLiteral<"continuation">;
+    deadlineAt: z.ZodNumber;
+    chunks: z.ZodArray<z.ZodObject<{
+        chunkNumber: z.ZodEffects<z.ZodNumber, number, number>;
+        dataKey: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        chunkNumber: number;
+        dataKey: string;
+    }, {
+        chunkNumber: number;
+        dataKey: string;
+    }>, "many">;
+    totalRows: z.ZodNumber;
+    totalBytes: z.ZodNumber;
+    fileKey: z.ZodOptional<z.ZodString>;
+    fileSize: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    acquisition: "continuation";
+    deadlineAt: number;
+    chunks: {
+        chunkNumber: number;
+        dataKey: string;
+    }[];
+    totalRows: number;
+    totalBytes: number;
+    fileKey?: string | undefined;
+    fileSize?: number | undefined;
+}, {
+    acquisition: "continuation";
+    deadlineAt: number;
+    chunks: {
+        chunkNumber: number;
+        dataKey: string;
+    }[];
+    totalRows: number;
+    totalBytes: number;
+    fileKey?: string | undefined;
+    fileSize?: number | undefined;
+}>, {
+    acquisition: "continuation";
+    deadlineAt: number;
+    chunks: {
+        chunkNumber: number;
+        dataKey: string;
+    }[];
+    totalRows: number;
+    totalBytes: number;
+    fileKey?: string | undefined;
+    fileSize?: number | undefined;
+}, {
+    acquisition: "continuation";
+    deadlineAt: number;
+    chunks: {
+        chunkNumber: number;
+        dataKey: string;
+    }[];
+    totalRows: number;
+    totalBytes: number;
+    fileKey?: string | undefined;
+    fileSize?: number | undefined;
+}>;
+export declare function parseMatrixManifest(value: unknown, jobId: string, deadlineAt: number): {
+    acquisition: "continuation";
+    deadlineAt: number;
+    chunks: {
+        chunkNumber: number;
+        dataKey: string;
+    }[];
+    totalRows: number;
+    totalBytes: number;
+    fileKey?: string | undefined;
+    fileSize?: number | undefined;
+};

package/dist/types/shared/format-utils/matrix-export-presentation.d.ts

@@ -0,0 +1,22 @@
+import { MatrixExportLayout, MatrixExportRequest, MatrixExportRow } from '../analytics-protocol/index.js';
+import { ReportRuntimeContext } from '../report-runtime-context/index.js';
+import { FastPathTableStructure } from './table-structure.js';
+/** Same descriptor-based presentation for viewer, layout CSV and print. */
+export declare function prepareMatrixExportPresentation(layout: MatrixExportLayout, request: MatrixExportRequest, report: ReportRuntimeContext): {
+    headers: string[];
+    headerBands: string[][];
+    row: (data: MatrixExportRow) => string[];
+    numericColumns: boolean[];
+    csvRow: (data: MatrixExportRow) => string[];
+    csvRows: (data: readonly MatrixExportRow[]) => string[][];
+};
+/** Raw CSV intentionally preserves typed values instead of display formats. */
+export declare function matrixFlatCsvHeaders(layout: MatrixExportLayout): string[];
+export declare function matrixFlatCsvRow(data: MatrixExportRow): (string | number | null)[];
+/** Bounded physical projection only; values and totals have already been acquired. */
+export declare function buildMatrixTableStructure(input: {
+    layout: MatrixExportLayout;
+    request: MatrixExportRequest;
+    rows: readonly MatrixExportRow[];
+    report: ReportRuntimeContext;
+}): FastPathTableStructure;

package/dist/types/shared/format-utils/numeric-presentation.d.ts

@@ -0,0 +1,36 @@
+import { NumericCanonicalFormat } from './types/index.js';
+import { ResolvedValueFormatPreferences } from '../value-format-preferences/index.js';
+import { PresentationExecutionSnapshot } from './presentation-execution.js';
+export type NumericCanonicalFormatParseResult = {
+    ok: true;
+    value: NumericCanonicalFormat;
+} | {
+    ok: false;
+    issues: Array<{
+        path: string;
+        message: string;
+    }>;
+};
+export type NumericPresentationTarget = {
+    kind: 'metric';
+    metricId: string;
+} | {
+    kind: 'column';
+    columnKey: string;
+} | {
+    kind: 'matrix_measure';
+    measureId: string;
+};
+export declare function parseNumericCanonicalFormat(input: unknown): NumericCanonicalFormatParseResult;
+export declare function parseResolvedNumericCanonicalFormat(input: unknown): NumericCanonicalFormatParseResult;
+export declare function validateCardExportNumericPresentationSnapshot(input: {
+    snapshot: PresentationExecutionSnapshot;
+    expectedScope: {
+        dashboardId: string;
+        cardId: string;
+    };
+    visibleColumns?: string[];
+    useFormattedValues: boolean;
+}): void;
+export declare function resolveCurrencyFractionDigits(locale: string, currency: string): Pick<NumericCanonicalFormat, 'minimumFractionDigits' | 'maximumFractionDigits'>;
+export declare function resolveNumericPresentation(authored: NumericCanonicalFormat, preferences: ResolvedValueFormatPreferences, boundCurrency?: string): NumericCanonicalFormat;

package/dist/types/shared/format-utils/pdf-delivery.d.ts

@@ -0,0 +1,25 @@
+export declare class PdfSafetyLimitError extends Error {
+    readonly code: "PDF_SAFETY_LIMIT_EXCEEDED";
+}
+export declare function readPdfErrorResponse(response: Response): Promise<{
+    message: string;
+    code?: string;
+}>;
+/** Shared structured HTTP transport, not a browser capture or acquisition engine. */
+export declare function requestStructuredPdf<T extends {
+    url?: string;
+    error?: string;
+} = {
+    url: string;
+    s3Bucket?: string;
+    s3Key?: string;
+    sizeBytes?: number;
+}>(input: {
+    url: string;
+    token: string;
+    serializedPayload: string;
+    signal?: AbortSignal;
+    fetchImpl?: typeof fetch;
+}): Promise<T & {
+    url: string;
+}>;

package/dist/types/shared/format-utils/pdf-export-policy.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Shared structured Fast PDF routing and safety policy.
+ *
+ * These values are product policy, not deployment configuration. Keep this
+ * module React-free so browser, app, and renderer adapters can enforce the
+ * same limits at their trust boundaries.
+ */
+export declare const FAST_PDF_POLICY: Readonly<{
+    maxRows: 5000;
+    maxRequestBytes: 2621440;
+    maxPages: 100;
+    maxOutputBytes: 52428800;
+}>;
+export declare const PDF_SAFETY_LIMIT_EXCEEDED: "PDF_SAFETY_LIMIT_EXCEEDED";
+/** Exact UTF-8 bytes used by the structured POST body. */
+export declare function getUtf8ByteLength(value: string): number;
+export declare function isFastPdfRowCountEligible(rowCount: number): boolean;
+export declare function isFastPdfRequestSizeEligible(byteLength: number): boolean;
+export declare function isFastPdfPageCountEligible(pageCount: number): boolean;
+export declare function isFastPdfOutputSizeEligible(byteLength: number): boolean;

package/dist/types/shared/format-utils/pivot-header-presentation.d.ts

@@ -0,0 +1,28 @@
+import { TemporalBucketMetadata } from '../analytics-protocol/contracts.js';
+import { ResolvedTemporalBucketFormat } from './temporal-bucket.js';
+export type PivotHeaderPresentationMember = {
+    fieldId: string;
+    value: string | null;
+    temporalBucket?: TemporalBucketMetadata;
+};
+export type PivotHeaderPresentation = {
+    memberLabels: string[];
+    metricLabel?: string;
+    flattenedLabel: string;
+};
+export type PivotHeaderPresentationMode = 'formatted' | 'canonical';
+export declare class PivotHeaderPresentationError extends Error {
+    readonly code: 'missing_resolved_temporal_format';
+    readonly deliveryBlocking = true;
+    constructor(code: 'missing_resolved_temporal_format', message: string);
+}
+/**
+ * React-free pivot header policy shared by interactive and delivery adapters.
+ * Canonical member values remain identity; this helper produces labels only.
+ */
+export declare function presentPivotHeader(input: {
+    members: readonly PivotHeaderPresentationMember[];
+    metricLabel?: string;
+    mode?: PivotHeaderPresentationMode;
+    resolveTemporalFormat?: (fieldId: string) => ResolvedTemporalBucketFormat | undefined;
+}): PivotHeaderPresentation;

package/dist/types/shared/format-utils/pivot-result-contract-expectations.d.ts

@@ -0,0 +1,28 @@
+import { MetricResultAliasInput } from '../analytics-protocol/index.js';
+import { PivotResultExpectedRoleFieldIds } from './pivot-result-lifecycle.js';
+type IdentifiedField = {
+    id?: string;
+};
+type IdentifiedMetricField = IdentifiedField & MetricResultAliasInput;
+export type PivotResultContractExpectations = {
+    expectedRoleFieldIds: PivotResultExpectedRoleFieldIds;
+    expectedMetricAliases: string[];
+};
+/**
+ * Returns the stable aliases required to distinguish repeated instances of
+ * one metric field. Unique metric fields remain role/field scoped.
+ */
+export declare function deriveMetricInstanceAliasExpectations(metrics: readonly IdentifiedMetricField[]): string[];
+/**
+ * Derives the authored identity expectations stored in a canonical pivot
+ * lifecycle contract. Producers and cache-compatibility consumers must use
+ * this same projection so generated Count and repeated metric instances cannot
+ * drift across the transport seam.
+ */
+export declare function derivePivotResultContractExpectations(input: {
+    groupByFields?: readonly IdentifiedField[];
+    metricFields?: readonly IdentifiedMetricField[];
+    pivotByFields?: readonly IdentifiedField[];
+    detailFields?: readonly IdentifiedField[];
+}): PivotResultContractExpectations;
+export {};

package/dist/types/shared/format-utils/pivot-result-identity.d.ts

@@ -0,0 +1,52 @@
+import { SemaphorPivotResultColumnIdentity, SemaphorPivotResultMember } from '../analytics-protocol/contracts.js';
+export type QueryColumnKeyRole = 'groupby' | 'metric' | 'pivotby' | 'detail';
+export interface QueryColumnKeyMapEntry {
+    role: QueryColumnKeyRole;
+    rawKey: string;
+    outputKey?: string;
+}
+export type QueryColumnKeyMapByRole = Partial<Record<QueryColumnKeyRole, Record<string, QueryColumnKeyMapEntry>>>;
+export interface QueryColumnKeyMap {
+    version: 1;
+    source: 'explorer';
+    byRole: QueryColumnKeyMapByRole;
+    byMetricAlias?: Record<string, QueryColumnKeyMapEntry>;
+}
+export type PivotResultColumnClassification = {
+    isSubtotal?: boolean;
+    subtotalScope?: 'base' | 'pivot-value' | 'grand-total';
+};
+export declare function isPivotSubtotalPrefix(classification: PivotResultColumnClassification | undefined): boolean;
+export declare function isPivotEmptyTupleAllowed(input: {
+    expectedPivotFieldIds: readonly string[];
+    classification?: PivotResultColumnClassification;
+}): boolean;
+export declare class PivotResultIdentityError extends Error {
+    readonly deliveryBlocking = true;
+    readonly code: "missing_pivot_member_identity";
+    constructor(message: string);
+}
+export declare function requirePivotHeaderMembers(input: {
+    identity: SemaphorPivotResultColumnIdentity;
+    columnKey: string;
+    expectedPivotFieldIds?: readonly string[];
+    allowPrefix?: boolean;
+    allowEmpty?: boolean;
+}): readonly SemaphorPivotResultMember[];
+export declare function requirePivotResultColumnIdentities(columns: readonly {
+    key: string;
+    pivotIdentity?: SemaphorPivotResultColumnIdentity;
+}[], options: {
+    expectedPivotFieldIds: readonly string[];
+    columnClassifications?: Readonly<Record<string, PivotResultColumnClassification | undefined>>;
+    allowPrefixForColumn?: (column: {
+        key: string;
+        pivotIdentity?: SemaphorPivotResultColumnIdentity;
+    }) => boolean;
+    allowEmptyForColumn?: (column: {
+        key: string;
+        pivotIdentity?: SemaphorPivotResultColumnIdentity;
+    }) => boolean;
+}): void;
+export declare function resolveQueryColumnKeyMapEntry(columnKeyMap: QueryColumnKeyMap | undefined, fieldId: string, role: QueryColumnKeyRole): QueryColumnKeyMapEntry | undefined;
+export declare function resolveUniqueQueryColumnKeyMapEntry(columnKeyMap: QueryColumnKeyMap | undefined, fieldId: string): QueryColumnKeyMapEntry | undefined;

package/dist/types/shared/format-utils/pivot-result-lifecycle.d.ts

@@ -0,0 +1,55 @@
+import { SemaphorResultColumn } from '../analytics-protocol/contracts.js';
+import { PivotResultColumnClassification, QueryColumnKeyMap, QueryColumnKeyRole } from './pivot-result-identity.js';
+export type CanonicalPivotResultState = 'loaded_empty' | 'loaded_valid';
+type CanonicalPivotResultBase = {
+    columns: SemaphorResultColumn[];
+    columnKeyMap: QueryColumnKeyMap;
+    pivotResultContract: CanonicalPivotResultContract;
+};
+export type LoadedEmptyPivotResult = CanonicalPivotResultBase & {
+    pivotResultState: 'loaded_empty';
+    records: [];
+};
+export type LoadedValidPivotResult = CanonicalPivotResultBase & {
+    pivotResultState: 'loaded_valid';
+    records: [Record<string, unknown>, ...Record<string, unknown>[]];
+};
+export type CanonicalPivotResultTransport = LoadedEmptyPivotResult | LoadedValidPivotResult;
+export declare class PivotResultLifecycleError extends Error {
+    readonly cause?: unknown | undefined;
+    readonly code: "invalid_pivot_result_lifecycle";
+    readonly deliveryBlocking = true;
+    constructor(message: string, cause?: unknown | undefined);
+}
+type PivotResultLifecycleInput = {
+    pivotResultState?: unknown;
+    pivotResultContract?: unknown;
+    records?: unknown;
+    columns?: unknown;
+    columnKeyMap?: unknown;
+};
+export type PivotResultExpectedRoleFieldIds = Readonly<Partial<Record<QueryColumnKeyRole, readonly string[]>>>;
+export type PivotResultColumnKind = 'row' | 'pivot_metric' | 'value';
+export type CanonicalPivotResultContract = {
+    version: 1;
+    expectedRoleFieldIds: PivotResultExpectedRoleFieldIds;
+    expectedMetricAliases: readonly string[];
+    columnKinds: Readonly<Record<string, PivotResultColumnKind>>;
+    columnClassifications: Readonly<Record<string, PivotResultColumnClassification | undefined>>;
+};
+/**
+ * Parses the canonical pivot wire shape once. Downstream presentation and
+ * delivery consumers receive this discriminated result and do not infer
+ * lifecycle or repeat physical-member validation.
+ */
+export declare function parseCanonicalPivotResultTransport(input: PivotResultLifecycleInput): CanonicalPivotResultTransport;
+export declare function createCanonicalPivotResultTransport(input: {
+    records: Record<string, unknown>[];
+    columns: SemaphorResultColumn[];
+    columnKeyMap: QueryColumnKeyMap;
+    expectedRoleFieldIds: PivotResultExpectedRoleFieldIds;
+    expectedMetricAliases?: readonly string[];
+    physicalPivotColumnKeys: readonly string[];
+    columnMetadata?: Readonly<Record<string, PivotResultColumnClassification | undefined>>;
+}): CanonicalPivotResultTransport;
+export {};

package/dist/types/shared/format-utils/presentation-execution.d.ts

@@ -0,0 +1,88 @@
+import { ResolvedRawTemporalFormat } from './raw-temporal.js';
+import { ReportRuntimeContext } from '../report-runtime-context/index.js';
+import { NumericPresentationTarget } from './numeric-presentation.js';
+import { ResolvedTemporalBucketFormat } from './temporal-bucket.js';
+import { NumericCanonicalFormat } from './types/index.js';
+export type PresentationScope = {
+    dashboardId: string;
+    cardId?: string;
+    attachmentIndex?: number;
+};
+export type TemporalBucketPresentationTarget = {
+    kind: 'field';
+    fieldId: string;
+    /** Distinguishes one semantic field used on both pivot axes. */
+    role?: 'groupby' | 'pivotby';
+} | {
+    kind: 'column';
+    columnKey: string;
+} | {
+    kind: 'matrix_axis';
+    axisInstanceId: string;
+};
+export type ResolvedNumericPresentationEntry = {
+    scope: PresentationScope;
+    target: NumericPresentationTarget;
+    format: NumericCanonicalFormat;
+};
+export type ResolvedTemporalBucketPresentationEntry = {
+    scope: PresentationScope;
+    target: TemporalBucketPresentationTarget;
+    format: ResolvedTemporalBucketFormat;
+};
+export type RawTemporalPresentationTarget = {
+    kind: 'column';
+    columnKey: string;
+};
+export type ResolvedRawTemporalPresentationEntry = {
+    scope: PresentationScope;
+    target: RawTemporalPresentationTarget;
+    format: ResolvedRawTemporalFormat;
+};
+export type ResolvedPresentationEntry = ResolvedNumericPresentationEntry | ResolvedTemporalBucketPresentationEntry | ResolvedRawTemporalPresentationEntry;
+export type PresentationExecutionSnapshot = {
+    version: 1;
+    reportContext: ReportRuntimeContext;
+    resolvedFormats: ResolvedPresentationEntry[];
+};
+export declare class PresentationExecutionSnapshotError extends Error {
+    readonly code = "invalid_presentation_execution_snapshot";
+    readonly deliveryBlocking = true;
+    constructor(message: string);
+}
+export declare class MissingResolvedRawTemporalFormatError extends Error {
+    readonly code = "missing_resolved_raw_temporal_format";
+    readonly deliveryBlocking = true;
+    constructor(columnKey: string);
+}
+export declare function parsePresentationScope(input: unknown, path?: string): PresentationScope;
+export declare function parseResolvedPresentationEntries(input: unknown): ResolvedPresentationEntry[];
+export declare function parsePresentationExecutionSnapshot(input: unknown): PresentationExecutionSnapshot;
+export declare function createPresentationExecutionSnapshot(input: {
+    reportContext: ReportRuntimeContext;
+    resolvedFormats: readonly ResolvedPresentationEntry[];
+}): PresentationExecutionSnapshot;
+export declare function findResolvedNumericFormat(input: {
+    snapshot: PresentationExecutionSnapshot;
+    scope: PresentationScope;
+    target: NumericPresentationTarget;
+}): NumericCanonicalFormat | undefined;
+export declare function findResolvedRawTemporalFormat(input: {
+    snapshot: PresentationExecutionSnapshot;
+    scope: PresentationScope;
+    target: RawTemporalPresentationTarget;
+}): ResolvedRawTemporalFormat | undefined;
+export declare function findResolvedTemporalBucketFormat(input: {
+    snapshot: PresentationExecutionSnapshot;
+    scope: PresentationScope;
+    target: TemporalBucketPresentationTarget;
+}): ResolvedTemporalBucketFormat | undefined;
+export declare function validateCardExportPresentationSnapshot(input: {
+    snapshot: PresentationExecutionSnapshot;
+    expectedScope: {
+        dashboardId: string;
+        cardId: string;
+    };
+    visibleColumns?: string[];
+    useFormattedValues: boolean;
+}): void;

package/dist/types/shared/format-utils/raw-temporal.d.ts

@@ -0,0 +1,89 @@
+import { CalendarContext } from '../report-runtime-context/report-runtime-context.js';
+import { RawTemporalValueKind, RawTemporalValueMetadata } from '../analytics-protocol/contracts.js';
+import { parseRawTemporalValueMetadata, validateRawTemporalResultColumn } from '../analytics-protocol/raw-temporal-contract.js';
+import { LocaleStyle, ResolvedValueFormatPreferences } from '../value-format-preferences/index.js';
+import { RawTemporalFormat, RawTemporalPatternDialect } from './types/format-types.js';
+export type { RawTemporalFormat, RawTemporalPatternDialect };
+export { parseRawTemporalValueMetadata, validateRawTemporalResultColumn, type RawTemporalValueKind, type RawTemporalValueMetadata, };
+export type ResolvedTemporalStyleSet = {
+    dateStyle: LocaleStyle;
+    dateTime: {
+        dateStyle: LocaleStyle;
+        timeStyle: LocaleStyle;
+    };
+};
+export type ResolvedRawTemporalFormat = {
+    type: 'raw_temporal';
+    locale: string;
+    calendarTimezone: string;
+    /** Resolved source timezone for timezone-less wall datetimes, when authored. */
+    sourceTimezone?: string;
+    presentation: {
+        mode: 'auto';
+        styles: ResolvedTemporalStyleSet;
+    } | {
+        mode: 'pattern';
+        dialect: RawTemporalPatternDialect;
+        pattern: string;
+    };
+};
+export type RawTemporalFormatResult = {
+    ok: true;
+    text: string;
+    status: 'formatted' | 'empty';
+} | {
+    ok: false;
+    text: string;
+    diagnostic: {
+        code: 'invalid_raw_temporal_value' | 'out_of_range_raw_temporal_value';
+        message: string;
+    };
+};
+/** Strictly prepared per-column formatter for repeated cell rendering. */
+export type PreparedRawTemporalFormatter = (value: string | null) => RawTemporalFormatResult;
+export type SqlTemporalColumnClassification = {
+    status: 'empty';
+} | {
+    status: 'invalid_only';
+} | {
+    status: 'classified';
+    metadata: RawTemporalValueMetadata;
+};
+export type RawTemporalChunkClassificationStatus = 'empty' | 'invalid_only' | RawTemporalValueKind;
+export type RawTemporalChunkClassificationEvidence = {
+    version: 1;
+    columns: Record<string, RawTemporalChunkClassificationStatus>;
+};
+export declare class RawTemporalFormatContractError extends Error {
+    readonly code: 'invalid_raw_temporal_format' | 'mixed_sql_temporal_semantics';
+    constructor(code: RawTemporalFormatContractError['code'], message: string);
+}
+export declare function parseResolvedRawTemporalFormat(input: unknown): ResolvedRawTemporalFormat;
+export declare function resolveRawTemporalFormat(input: {
+    format?: RawTemporalFormat;
+    preferences: ResolvedValueFormatPreferences;
+    calendar: Pick<CalendarContext, 'tz'>;
+}): ResolvedRawTemporalFormat;
+export declare function classifyDeclaredSqlTemporalColumn(input: {
+    columnKey: string;
+    values: readonly (string | null)[];
+}): SqlTemporalColumnClassification;
+export declare function createRawTemporalChunkClassificationEvidence(classifications: ReadonlyMap<string, SqlTemporalColumnClassification>): RawTemporalChunkClassificationEvidence;
+export declare function parseRawTemporalChunkClassificationEvidence(input: unknown): RawTemporalChunkClassificationEvidence;
+export declare function assertRawTemporalChunkClassificationAgreement(inputs: readonly unknown[]): void;
+/** Validates an authored pattern without formatting or inventing a fallback. */
+export declare function validateRawTemporalPattern(input: {
+    valueKind?: RawTemporalValueKind;
+    dialect: RawTemporalPatternDialect;
+    pattern: string;
+}): void;
+export declare function prepareRawTemporalFormatter(input: {
+    metadata: RawTemporalValueMetadata;
+    format: ResolvedRawTemporalFormat;
+}): PreparedRawTemporalFormatter;
+/** Strict one-off convenience; row loops should prepare once per column. */
+export declare function formatRawTemporalValue(input: {
+    value: string | null;
+    metadata: RawTemporalValueMetadata;
+    format: ResolvedRawTemporalFormat;
+}): RawTemporalFormatResult;