metrickit 0.1.2

package/dist/engine.d.ts

@@ -0,0 +1,200 @@
+import type { z } from 'zod';
+import type { CacheAdapter } from './cache.ts';
+import type { MetricCatalogMetadata } from './catalog.ts';
+import type { AnyMetricDefinition, MetricDefinition, MetricDefinitionInput } from './define-metric.ts';
+import type { BaseFilters, OutputForKind, TimeSeriesOutput } from './schemas/index.ts';
+import { OutputSchemaMap } from './schemas/index.ts';
+export type MetricKindSchemaMap = Record<string, z.ZodTypeAny>;
+type BuiltinMetricKindSchemaMap = typeof OutputSchemaMap;
+type EngineMetricKindSchemaMap<TCustomKinds extends MetricKindSchemaMap> = BuiltinMetricKindSchemaMap & TCustomKinds;
+type OutputForSchema<TSchema extends z.ZodTypeAny> = z.output<TSchema>;
+type EmptyMetricKindSchemaMap = Record<string, never>;
+export interface MetricsEngineConfig<TBaseFilters extends BaseFilters, TCustomKinds extends MetricKindSchemaMap = EmptyMetricKindSchemaMap> {
+    baseFilters?: z.ZodType<TBaseFilters>;
+    cache?: CacheAdapter;
+    customKinds?: TCustomKinds;
+}
+export declare function createMetricsEngine<TContext, TBaseFilters extends BaseFilters = BaseFilters, TCustomKinds extends MetricKindSchemaMap = EmptyMetricKindSchemaMap>(config?: MetricsEngineConfig<TBaseFilters, TCustomKinds>): {
+    cache: CacheAdapter;
+    baseFilterSchema: z.ZodType<TBaseFilters, unknown, z.core.$ZodTypeInternals<TBaseFilters, unknown>>;
+    kindSchemas: EngineMetricKindSchemaMap<TCustomKinds>;
+    defineMetric: <TKey extends string, TKind extends "kpi" | "timeseries" | "distribution" | "table" | "leaderboard" | "pivot" | Extract<keyof TCustomKinds, string>, TFilters extends TBaseFilters, TCatalog extends MetricCatalogMetadata | undefined = MetricCatalogMetadata | undefined>(kind: TKind, def: MetricDefinitionInput<TKey, TKind, TFilters, OutputForSchema<EngineMetricKindSchemaMap<TCustomKinds>[TKind]>, TContext, TCatalog>) => MetricDefinition<TKey, TKind, TFilters, OutputForSchema<EngineMetricKindSchemaMap<TCustomKinds>[TKind]>, TContext, TCatalog>;
+    defineKpiMetric: <TKey extends string, TFilters extends TBaseFilters, TCatalog extends MetricCatalogMetadata | undefined = MetricCatalogMetadata | undefined>(def: MetricDefinitionInput<TKey, "kpi", TFilters, OutputForKind<"kpi">, TContext, TCatalog>) => MetricDefinition<TKey, "kpi", TFilters, OutputForKind<"kpi">, TContext, TCatalog>;
+    defineTimeSeriesMetric: <TKey extends string, TFilters extends TBaseFilters, TCatalog extends MetricCatalogMetadata | undefined = MetricCatalogMetadata | undefined>(def: MetricDefinitionInput<TKey, "timeseries", TFilters, TimeSeriesOutput, TContext, TCatalog>) => MetricDefinition<TKey, "timeseries", TFilters, TimeSeriesOutput, TContext, TCatalog>;
+    defineDistributionMetric: <TKey extends string, TFilters extends TBaseFilters, TCatalog extends MetricCatalogMetadata | undefined = MetricCatalogMetadata | undefined>(def: MetricDefinitionInput<TKey, "distribution", TFilters, OutputForKind<"distribution">, TContext, TCatalog>) => MetricDefinition<TKey, "distribution", TFilters, OutputForKind<"distribution">, TContext, TCatalog>;
+    defineTableMetric: <TKey extends string, TFilters extends TBaseFilters, TCatalog extends MetricCatalogMetadata | undefined = MetricCatalogMetadata | undefined>(def: MetricDefinitionInput<TKey, "table", TFilters, OutputForKind<"table">, TContext, TCatalog>) => MetricDefinition<TKey, "table", TFilters, OutputForKind<"table">, TContext, TCatalog>;
+    defineLeaderboardMetric: <TKey extends string, TFilters extends TBaseFilters, TCatalog extends MetricCatalogMetadata | undefined = MetricCatalogMetadata | undefined>(def: MetricDefinitionInput<TKey, "leaderboard", TFilters, OutputForKind<"leaderboard">, TContext, TCatalog>) => MetricDefinition<TKey, "leaderboard", TFilters, OutputForKind<"leaderboard">, TContext, TCatalog>;
+    definePivotMetric: <TKey extends string, TFilters extends TBaseFilters, TCatalog extends MetricCatalogMetadata | undefined = MetricCatalogMetadata | undefined>(def: MetricDefinitionInput<TKey, "pivot", TFilters, OutputForKind<"pivot">, TContext, TCatalog>) => MetricDefinition<TKey, "pivot", TFilters, OutputForKind<"pivot">, TContext, TCatalog>;
+    createRegistry: <const TMetrics extends readonly AnyMetricDefinition[]>(metrics: TMetrics) => {
+        readonly metrics: TMetrics;
+        readonly baseFilterSchema: z.ZodType<TBaseFilters, unknown, z.core.$ZodTypeInternals<TBaseFilters, unknown>>;
+        readonly kindSchemas: {
+            readonly kpi: z.ZodObject<{
+                kind: z.ZodLiteral<"kpi">;
+                value: z.ZodNumber;
+                label: z.ZodOptional<z.ZodString>;
+                unit: z.ZodOptional<z.ZodEnum<{
+                    DKK: "DKK";
+                    EUR: "EUR";
+                    USD: "USD";
+                    GBP: "GBP";
+                    SEK: "SEK";
+                    NOK: "NOK";
+                    PERCENTAGE: "PERCENTAGE";
+                }>>;
+                prefix: z.ZodOptional<z.ZodString>;
+                suffix: z.ZodOptional<z.ZodString>;
+                trend: z.ZodOptional<z.ZodEnum<{
+                    up: "up";
+                    down: "down";
+                    flat: "flat";
+                }>>;
+            }, z.core.$strip>;
+            readonly timeseries: z.ZodObject<{
+                kind: z.ZodLiteral<"timeseries">;
+                granularity: z.ZodEnum<{
+                    hour: "hour";
+                    day: "day";
+                    week: "week";
+                    month: "month";
+                    quarter: "quarter";
+                    year: "year";
+                }>;
+                series: z.ZodArray<z.ZodObject<{
+                    key: z.ZodString;
+                    label: z.ZodOptional<z.ZodString>;
+                    points: z.ZodArray<z.ZodObject<{
+                        ts: z.ZodDate;
+                        value: z.ZodNumber;
+                        label: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strip>>;
+                    chartType: z.ZodOptional<z.ZodEnum<{
+                        line: "line";
+                        bar: "bar";
+                    }>>;
+                    axis: z.ZodOptional<z.ZodEnum<{
+                        left: "left";
+                        right: "right";
+                    }>>;
+                    meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>;
+            readonly distribution: z.ZodObject<{
+                kind: z.ZodLiteral<"distribution">;
+                total: z.ZodNumber;
+                segments: z.ZodArray<z.ZodObject<{
+                    key: z.ZodString;
+                    label: z.ZodString;
+                    value: z.ZodNumber;
+                    percent: z.ZodOptional<z.ZodNumber>;
+                }, z.core.$strip>>;
+                chartType: z.ZodOptional<z.ZodEnum<{
+                    bar: "bar";
+                    donut: "donut";
+                    pie: "pie";
+                    funnel: "funnel";
+                }>>;
+            }, z.core.$strip>;
+            readonly table: z.ZodObject<{
+                kind: z.ZodLiteral<"table">;
+                columns: z.ZodArray<z.ZodObject<{
+                    key: z.ZodString;
+                    label: z.ZodString;
+                    type: z.ZodOptional<z.ZodEnum<{
+                        string: "string";
+                        number: "number";
+                        boolean: "boolean";
+                        date: "date";
+                    }>>;
+                    nullable: z.ZodOptional<z.ZodBoolean>;
+                }, z.core.$strip>>;
+                rows: z.ZodArray<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                total: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>;
+            readonly leaderboard: z.ZodObject<{
+                kind: z.ZodLiteral<"leaderboard">;
+                items: z.ZodArray<z.ZodObject<{
+                    rank: z.ZodNumber;
+                    id: z.ZodString;
+                    label: z.ZodString;
+                    value: z.ZodNumber;
+                    meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                }, z.core.$strip>>;
+                total: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>;
+            readonly pivot: z.ZodObject<{
+                kind: z.ZodLiteral<"pivot">;
+                rowDimension: z.ZodObject<{
+                    key: z.ZodString;
+                    label: z.ZodString;
+                }, z.core.$strip>;
+                columnDimension: z.ZodObject<{
+                    key: z.ZodString;
+                    label: z.ZodString;
+                }, z.core.$strip>;
+                rows: z.ZodArray<z.ZodString>;
+                columns: z.ZodArray<z.ZodString>;
+                values: z.ZodArray<z.ZodArray<z.ZodNumber>>;
+                cellTooltips: z.ZodOptional<z.ZodArray<z.ZodArray<z.ZodString>>>;
+                totals: z.ZodOptional<z.ZodObject<{
+                    rowTotals: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+                    columnTotals: z.ZodOptional<z.ZodArray<z.ZodNumber>>;
+                    grandTotal: z.ZodOptional<z.ZodNumber>;
+                }, z.core.$strip>>;
+            }, z.core.$strip>;
+        } & TCustomKinds;
+        readonly metricKeys: [TMetrics[number]["key"], ...TMetrics[number]["key"][]];
+        readonly MetricKeySchema: z.ZodEnum<{ [k_1 in TMetrics[number]["key"]]: k_1; } extends infer T ? { [k in keyof T]: T[k]; } : never>;
+        readonly MetricRequestSchema: z.ZodObject<{
+            key: z.ZodEnum<{ [k_1 in TMetrics[number]["key"]]: k_1; } extends infer T_1 ? { [k in keyof T_1]: T_1[k]; } : never>;
+            requestKey: z.ZodOptional<z.ZodString>;
+            filters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$strip>;
+        readonly MetricsRequestSchema: z.ZodObject<{
+            metrics: z.ZodArray<z.ZodObject<{
+                key: z.ZodEnum<{ [k_1 in TMetrics[number]["key"]]: k_1; } extends infer T_2 ? { [k in keyof T_2]: T_2[k]; } : never>;
+                requestKey: z.ZodOptional<z.ZodString>;
+                filters: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            }, z.core.$strip>>;
+            granularity: z.ZodOptional<z.ZodEnum<{
+                hour: "hour";
+                day: "day";
+                week: "week";
+                month: "month";
+                quarter: "quarter";
+                year: "year";
+            }>>;
+            from: z.ZodOptional<z.ZodDate>;
+            to: z.ZodOptional<z.ZodDate>;
+            compareToPrevious: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+            disableCache: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        }, z.core.$strip>;
+        readonly metricsByKey: Record<TMetrics[number]["key"], AnyMetricDefinition>;
+        readonly getMetricByKey: {
+            <K extends TMetrics[number]["key"]>(key: K): Extract<TMetrics[number], {
+                key: K;
+            }>;
+            (key: string): AnyMetricDefinition | undefined;
+        };
+        readonly parseMetricRequestInput: <K extends TMetrics[number]["key"], TRequestKey extends string | undefined = string | undefined>(metricRequest: {
+            key: K;
+            requestKey?: TRequestKey | undefined;
+            filters?: Partial<Omit<z.core.output<Extract<TMetrics[number], {
+                key: K;
+            }>["filterSchema"]>, "from" | "to">> | undefined;
+        }, options?: {
+            from?: Date;
+            to?: Date;
+        } | undefined) => {
+            metric: Extract<TMetrics[number], {
+                key: K;
+            }>;
+            requestKey: K;
+            filters: z.core.output<Extract<TMetrics[number], {
+                key: K;
+            }>["filterSchema"]>;
+        };
+        readonly getOutputSchema: typeof import("./define-metric.ts").getOutputSchema;
+    };
+};
+export {};

package/dist/filters/default-metadata.d.ts

@@ -0,0 +1,28 @@
+import { type MetricFilterFieldMetadata } from './types.ts';
+export declare const COMMON_METRIC_FILTER_FIELD_METADATA: {
+    metric: {
+        displayName: string;
+        description: string;
+        defaultOperator: "is";
+    };
+    groupBy: {
+        displayName: string;
+        description: string;
+        defaultOperator: "is";
+    };
+    limit: {
+        displayName: string;
+        description: string;
+    };
+    view: {
+        displayName: string;
+        description: string;
+        defaultOperator: "is";
+    };
+    chartType: {
+        displayName: string;
+        description: string;
+        defaultOperator: "is";
+    };
+};
+export declare function mergeMetricFilterFieldMetadata(...metadataEntries: Array<Partial<Record<string, MetricFilterFieldMetadata>> | undefined>): Partial<Record<string, MetricFilterFieldMetadata>>;

package/dist/filters/index.d.ts

@@ -0,0 +1,3 @@
+export * from './types.ts';
+export { parseMetricFilterSchema } from './parse.ts';
+export { COMMON_METRIC_FILTER_FIELD_METADATA, mergeMetricFilterFieldMetadata } from './default-metadata.ts';

package/dist/filters/parse.d.ts

@@ -0,0 +1,7 @@
+import type { z } from 'zod';
+import type { FilterFieldDefinition, MetricFilterFieldMetadata } from './types.ts';
+export declare function parseMetricFilterSchema(schema: z.ZodTypeAny, options?: {
+    excludeFields?: string[];
+    includeFields?: string[];
+    fieldMetadata?: Partial<Record<string, MetricFilterFieldMetadata>>;
+}): FilterFieldDefinition[];

package/dist/filters/types.d.ts

@@ -0,0 +1,19 @@
+export type FilterFieldType = 'text' | 'number' | 'numberRange' | 'boolean' | 'date' | 'option' | 'multiOption';
+export type FilterFieldOption = {
+    label: string;
+    value: string;
+};
+export type FilterOperator = 'contains' | 'does not contain' | 'equals' | 'not equals' | 'greater than' | 'greater than or equal' | 'less than' | 'less than or equal' | 'between' | 'in range' | 'is true' | 'is false' | 'is' | 'is not' | 'is before' | 'is after' | 'is on or before' | 'is on or after' | 'is any of' | 'is none of' | 'includes' | 'excludes' | 'includes any of' | 'includes all of' | 'excludes any of';
+export interface MetricFilterFieldMetadata {
+    displayName?: string;
+    description?: string;
+    type?: FilterFieldType;
+    options?: FilterFieldOption[];
+    defaultOperator?: FilterOperator;
+}
+export interface FilterFieldDefinition extends MetricFilterFieldMetadata {
+    id: string;
+    displayName: string;
+    type: FilterFieldType;
+}
+export declare function defineMetricFilterFieldMetadata<T extends Record<string, MetricFilterFieldMetadata>>(metadata: T): T;

package/dist/frontend/catalog.d.ts

@@ -0,0 +1,24 @@
+import type { FilterFieldDefinition } from '../filters/types.ts';
+type AvailableMetricLike = {
+    key: string;
+    kind: string;
+    filters: readonly FilterFieldDefinition[];
+};
+export type AvailableMetricMap<TMetrics extends readonly AvailableMetricLike[]> = {
+    [K in TMetrics[number]['key']]: Extract<TMetrics[number], {
+        key: K;
+    }>;
+};
+export declare function createAvailableMetricMap<const TMetrics extends readonly AvailableMetricLike[]>(metrics: TMetrics): AvailableMetricMap<TMetrics>;
+export declare function getAvailableMetric<const TMetrics extends readonly AvailableMetricLike[], K extends TMetrics[number]['key']>(metrics: TMetrics, key: K): Extract<TMetrics[number], {
+    key: K;
+}> | undefined;
+export declare function getMetricFilterFields(metric: {
+    filters: readonly FilterFieldDefinition[];
+} | undefined): readonly FilterFieldDefinition[];
+export declare function groupAvailableMetricsByKind<const TMetrics extends readonly AvailableMetricLike[]>(metrics: TMetrics): {
+    [K in TMetrics[number]['kind']]: Array<Extract<TMetrics[number], {
+        kind: K;
+    }>>;
+};
+export {};

package/dist/frontend/dashboard.d.ts

@@ -0,0 +1,12 @@
+import type { AnyRegistry, InferAvailableMetricKey } from '../registry.ts';
+import type { DashboardControls, DashboardItem, DashboardSlotId, MetricsCustomSlotConfig, MetricsDashboardConfig, MetricsHeadlineConfig, MetricsSpacerConfig, MetricsWidgetConfig, WidgetLayout } from './types.ts';
+export declare function defineMetricsDashboard<R extends AnyRegistry, TRendererId extends string = string, TSlotId extends string = DashboardSlotId, const Items extends readonly DashboardItem<R, TRendererId, TSlotId>[] = readonly DashboardItem<R, TRendererId, TSlotId>[]>(config: MetricsDashboardConfig<R, TRendererId, TSlotId, Items>): MetricsDashboardConfig<R, TRendererId, TSlotId, Items>;
+export declare function defineWidget<R extends AnyRegistry, const K extends InferAvailableMetricKey<R>, TRequestKey extends string | undefined = string | undefined, TRendererId extends string = string>(key: K, config?: Omit<MetricsWidgetConfig<R, K, TRequestKey, TRendererId>, 'key'>): MetricsWidgetConfig<R, K, TRequestKey, TRendererId>;
+export declare function defineWidget<R extends AnyRegistry, const K extends InferAvailableMetricKey<R>, TRequestKey extends string | undefined = string | undefined, TRendererId extends string = string>(config: MetricsWidgetConfig<R, K, TRequestKey, TRendererId>): MetricsWidgetConfig<R, K, TRequestKey, TRendererId>;
+export declare function defineHeadline(title: string, description?: string): MetricsHeadlineConfig;
+export declare function defineSpacer(layout?: WidgetLayout): MetricsSpacerConfig;
+export declare function defineCustomSlot<TSlotId extends string>(slotId: TSlotId, config?: {
+    layout?: WidgetLayout;
+    props?: Record<string, unknown>;
+}): MetricsCustomSlotConfig<TSlotId>;
+export declare const defaultDashboardControls: DashboardControls;

package/dist/frontend/format.d.ts

@@ -0,0 +1,10 @@
+import type { MetricUnit } from '../schemas/output.ts';
+export interface MetricFormatOptions {
+    locale?: string;
+    defaultCurrency?: string;
+    maximumFractionDigits?: number;
+}
+export declare function formatMetricNumber(value: number, options?: MetricFormatOptions): string;
+export declare function formatMetricDecimal(value: number | undefined, options?: MetricFormatOptions): string;
+export declare function formatMetricCurrency(value: number, currency?: string, options?: MetricFormatOptions): string;
+export declare function formatKpiValue(value: number, unit?: MetricUnit, prefix?: string, suffix?: string, options?: MetricFormatOptions): string;

package/dist/frontend/index.d.ts

@@ -0,0 +1,10 @@
+export * from './types.ts';
+export * from './requests.ts';
+export * from './transport.ts';
+export * from './stream-state.ts';
+export * from './catalog.ts';
+export * from './format.ts';
+export * from './time.ts';
+export * from './markers.ts';
+export * from './dashboard.ts';
+export * from './renderers.ts';

package/dist/frontend/markers.d.ts

@@ -0,0 +1,19 @@
+import type { ChartMarker, MarkerCategory } from './types.ts';
+export declare const SEVERITY_COLORS: Record<string, string>;
+export interface LogItemForMarker {
+    id: string;
+    createdAt: Date | string;
+    data?: {
+        type: string;
+        title: string;
+        description?: string;
+        severity?: 'info' | 'success' | 'warning' | 'danger';
+        icon?: string;
+    };
+}
+export declare function getMarkerTypes(markers: readonly ChartMarker[]): string[];
+export declare function filterChartMarkers(markers: readonly ChartMarker[], enabledTypes: ReadonlySet<string>): ChartMarker[];
+export declare function getMarkerCategories(markers: readonly ChartMarker[], enabledTypes: ReadonlySet<string>): MarkerCategory[];
+export declare function toggleMarkerType(enabledTypes: ReadonlySet<string>, type: string): Set<string>;
+export declare function toggleAllMarkerTypes(markers: readonly ChartMarker[], enabled: boolean): Set<string>;
+export declare function mapLogItemsToMarkers(items: readonly LogItemForMarker[]): ChartMarker[];

package/dist/frontend/renderers.d.ts

@@ -0,0 +1,14 @@
+import type { AnyRegistry, InferAvailableMetricKey, InferRegistryMetrics, MetricKindFor } from '../registry.ts';
+export interface MetricsRendererRegistry<R extends AnyRegistry = AnyRegistry, TRendererId extends string = string> {
+    byKind?: Partial<Record<Extract<InferRegistryMetrics<R>[number]['kind'], string>, TRendererId>>;
+    byMetricKey?: Partial<Record<InferAvailableMetricKey<R>, TRendererId>>;
+}
+export interface MetricRendererHandle<K extends string = string, TKind extends string = string, TRendererId extends string = string> {
+    rendererId: TRendererId | `kind:${TKind}`;
+    source: 'metric' | 'kind' | 'fallback';
+    metricKey: K;
+    kind: TKind;
+}
+export declare function defineRendererRegistry<R extends AnyRegistry, TRendererId extends string, TRegistry extends MetricsRendererRegistry<R, TRendererId>>(registry: TRegistry): TRegistry;
+export declare function hasCustomRenderer<R extends AnyRegistry, K extends InferAvailableMetricKey<R>, TRendererId extends string>(metricKey: K, registry?: MetricsRendererRegistry<R, TRendererId>): boolean;
+export declare function resolveRendererHandle<R extends AnyRegistry, K extends InferAvailableMetricKey<R>, TRendererId extends string = string>(metricKey: K, kind: MetricKindFor<R, K>, registry?: MetricsRendererRegistry<R, TRendererId>): MetricRendererHandle<K, MetricKindFor<R, K>, TRendererId>;

package/dist/frontend/requests.d.ts

@@ -0,0 +1,17 @@
+import type { AnyRegistry, InferAvailableMetricKey, MetricRequestFor, MetricResultChunkFor, MetricsExecutionResult, MetricsRequestFor, RequestedMetricKeys } from '../registry.ts';
+export { getMetricResultKey as getRequestedMetricKey } from '../registry.ts';
+export type FrontendMetricRequest<R extends AnyRegistry, K extends InferAvailableMetricKey<R> = InferAvailableMetricKey<R>, TRequestKey extends string | undefined = string | undefined> = MetricRequestFor<R, K, TRequestKey>;
+export type FrontendMetricsRequest<R extends AnyRegistry> = MetricsRequestFor<R>;
+export type FrontendMetricsResult<R extends AnyRegistry, TMetricRequests extends readonly FrontendMetricRequest<R>[]> = MetricsExecutionResult<R, TMetricRequests>;
+export type FrontendMetricResultChunk<R extends AnyRegistry, TMetricRequests extends readonly FrontendMetricRequest<R>[]> = MetricResultChunkFor<R, TMetricRequests>;
+export declare function defineMetricRequest<R extends AnyRegistry, K extends InferAvailableMetricKey<R>, TRequestKey extends string | undefined = string | undefined>(request: FrontendMetricRequest<R, K, TRequestKey>): FrontendMetricRequest<R, K, TRequestKey>;
+export declare function defineMetricsRequest<R extends AnyRegistry, const TMetricRequests extends readonly FrontendMetricRequest<R>[] = readonly FrontendMetricRequest<R>[]>(request: Omit<FrontendMetricsRequest<R>, 'metrics'> & {
+    metrics: TMetricRequests;
+}): Omit<FrontendMetricsRequest<R>, 'metrics'> & {
+    metrics: TMetricRequests;
+};
+export declare function getMetricResult<R extends AnyRegistry, TMetricRequests extends readonly FrontendMetricRequest<R>[], K extends RequestedMetricKeys<R, TMetricRequests>>(result: FrontendMetricsResult<R, TMetricRequests>, key: K): { [TResultKey in TMetricRequests[number] extends infer T ? T extends TMetricRequests[number] ? T extends {
+    requestKey: infer TRequestKey extends string;
+} ? TRequestKey : T extends {
+    key: infer TMetricKey extends string;
+} ? TMetricKey : never : never : never]?: import("../registry.ts").MetricResultForResultKey<R, TMetricRequests, TResultKey> | undefined; }[K];

package/dist/frontend/stream-state.d.ts

@@ -0,0 +1,14 @@
+import type { AnyRegistry, MetricRequestFor, MetricResultChunkFor, MetricsExecutionResult, RequestedMetricKeys } from '../registry.ts';
+export interface MetricsStreamState<R extends AnyRegistry, TMetricRequests extends readonly MetricRequestFor<R>[]> extends MetricsExecutionResult<R, TMetricRequests> {
+    status: 'idle' | 'streaming' | 'complete';
+    done: boolean;
+    receivedKeys: RequestedMetricKeys<R, TMetricRequests>[];
+    pendingKeys: RequestedMetricKeys<R, TMetricRequests>[];
+}
+export declare function getPendingMetricKeys<R extends AnyRegistry, TMetricRequests extends readonly MetricRequestFor<R>[]>(request: {
+    metrics: TMetricRequests;
+}): RequestedMetricKeys<R, TMetricRequests>[];
+export declare function createMetricsStreamState<R extends AnyRegistry, TMetricRequests extends readonly MetricRequestFor<R>[]>(request: {
+    metrics: TMetricRequests;
+}): MetricsStreamState<R, TMetricRequests>;
+export declare function applyMetricResultChunk<R extends AnyRegistry, TMetricRequests extends readonly MetricRequestFor<R>[]>(state: MetricsStreamState<R, TMetricRequests>, chunk: MetricResultChunkFor<R, TMetricRequests>): MetricsStreamState<R, TMetricRequests>;

package/dist/frontend/time.d.ts

@@ -0,0 +1,5 @@
+export interface RangeLabelOptions {
+    now?: Date;
+    locale?: string;
+}
+export declare function computeRangeLabel(from: Date | undefined, to: Date | undefined, options?: RangeLabelOptions): string;

package/dist/frontend/transport.d.ts

@@ -0,0 +1,19 @@
+import type { AvailableMetricsResult } from '../orpc.ts';
+import type { AnyRegistry, MetricsRequestFor } from '../registry.ts';
+import type { MetricRequestFor, MetricResultChunkFor, MetricsExecutionResult } from '../registry.ts';
+export interface MetricsBatchTransport<R extends AnyRegistry = AnyRegistry> {
+    run<TRequest extends MetricsRequestFor<R>>(request: TRequest): Promise<MetricsExecutionResult<R, TRequest['metrics']>>;
+}
+export interface MetricsStreamTransport<R extends AnyRegistry = AnyRegistry> {
+    stream<TRequest extends MetricsRequestFor<R>>(request: TRequest): AsyncIterable<MetricResultChunkFor<R, TRequest['metrics']>>;
+}
+export interface MetricsCatalogTransport<R extends AnyRegistry = AnyRegistry> {
+    getAvailableMetrics(): Promise<AvailableMetricsResult<R>>;
+}
+export interface MetricsTransport<R extends AnyRegistry = AnyRegistry> extends MetricsBatchTransport<R>, MetricsStreamTransport<R>, MetricsCatalogTransport<R> {
+}
+export interface MetricsStreamHandlers<R extends AnyRegistry, TMetricRequests extends readonly MetricRequestFor<R>[]> {
+    onChunk?: (chunk: MetricResultChunkFor<R, TMetricRequests>) => void;
+    onError?: (error: unknown) => void;
+    onComplete?: () => void;
+}

package/dist/frontend/types.d.ts

@@ -0,0 +1,108 @@
+import type { AvailableMetricFor, AvailableMetricsResult } from '../orpc.ts';
+import type { AnyRegistry, InferAvailableMetricKey, MetricOutputFor, MetricRequestFor, MetricRequestFiltersFor, MetricRequestResultKey } from '../registry.ts';
+import type { MetricResult } from '../schemas/output.ts';
+import type { TimeGranularity } from '../schemas/time.ts';
+import type { MetricsRendererRegistry } from './renderers.ts';
+export type DashboardSlotId = string;
+export type RendererId = string;
+export interface WidgetLayout {
+    cols?: 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12;
+    rows?: number;
+    minHeight?: string;
+}
+export type BarMode = 'stacked' | 'grouped';
+export interface DashboardControls {
+    showTimeRange?: boolean;
+    showGranularity?: boolean;
+    showCompare?: boolean;
+    showFilters?: boolean;
+    defaultFrom?: Date;
+    defaultTo?: Date;
+    defaultGranularity?: TimeGranularity;
+    defaultCompareToPrevious?: boolean;
+    defaultDisableCache?: boolean;
+}
+export interface MetricsFilterControlConfig<R extends AnyRegistry, K extends InferAvailableMetricKey<R>> {
+    scope?: 'dashboard' | 'widget' | 'both';
+    includeFields?: Array<Extract<keyof MetricRequestFiltersFor<R, K>, string>>;
+}
+export interface MetricsWidgetConfig<R extends AnyRegistry, K extends InferAvailableMetricKey<R> = InferAvailableMetricKey<R>, TRequestKey extends string | undefined = string | undefined, TRendererId extends string = RendererId> {
+    key: K;
+    requestKey?: TRequestKey;
+    title?: string;
+    description?: string;
+    layout?: WidgetLayout;
+    filters?: Partial<MetricRequestFiltersFor<R, K>>;
+    filterControls?: MetricsFilterControlConfig<R, K>;
+    rendererId?: TRendererId;
+    barMode?: BarMode;
+    showTrendLine?: boolean;
+}
+export interface MetricsHeadlineConfig {
+    _type: 'headline';
+    title: string;
+    description?: string;
+}
+export interface MetricsSpacerConfig {
+    _type: 'spacer';
+    layout?: WidgetLayout;
+}
+export interface MetricsCustomSlotConfig<TSlotId extends string = DashboardSlotId> {
+    _type: 'slot';
+    slotId: TSlotId;
+    layout?: WidgetLayout;
+    props?: Record<string, unknown>;
+}
+export type DashboardItem<R extends AnyRegistry = AnyRegistry, TRendererId extends string = RendererId, TSlotId extends string = DashboardSlotId> = MetricsWidgetConfig<R, InferAvailableMetricKey<R>, string | undefined, TRendererId> | MetricsHeadlineConfig | MetricsSpacerConfig | MetricsCustomSlotConfig<TSlotId>;
+export interface MetricsDashboardConfig<R extends AnyRegistry = AnyRegistry, TRendererId extends string = RendererId, TSlotId extends string = DashboardSlotId, Items extends readonly DashboardItem<R, TRendererId, TSlotId>[] = readonly DashboardItem<R, TRendererId, TSlotId>[]> {
+    title?: string;
+    description?: string;
+    controls?: DashboardControls;
+    persistKey?: string;
+    widgets: Items;
+    renderers?: MetricsRendererRegistry<R, TRendererId>;
+    markers?: ChartMarker[];
+}
+export interface WidgetState<TOutput = unknown> {
+    isLoading: boolean;
+    result?: MetricResult<TOutput>;
+    error?: string;
+}
+type DashboardWidgetItem<R extends AnyRegistry, TRendererId extends string = RendererId> = MetricsWidgetConfig<R, InferAvailableMetricKey<R>, string | undefined, TRendererId>;
+type DashboardMetricRequestFromItem<R extends AnyRegistry, TItem> = TItem extends MetricsWidgetConfig<infer K extends InferAvailableMetricKey<R>, infer TRequestKey extends string | undefined, infer _TRendererId extends string> ? MetricRequestFor<R, K, TRequestKey> : never;
+type DashboardItemResultKey<R extends AnyRegistry, TItem> = DashboardMetricRequestFromItem<R, TItem> extends infer TMetricRequest ? TMetricRequest extends MetricRequestFor<R> ? MetricRequestResultKey<TMetricRequest> : never : never;
+type DashboardItemForResultKey<R extends AnyRegistry, Items extends readonly DashboardItem<R, string, string>[], TResultKey extends DashboardResultKey<R, Items>> = Extract<Extract<Items[number], DashboardWidgetItem<R>>, {
+    requestKey: TResultKey;
+}> extends never ? Extract<Extract<Items[number], DashboardWidgetItem<R>>, {
+    key: TResultKey;
+}> : Extract<Extract<Items[number], DashboardWidgetItem<R>>, {
+    requestKey: TResultKey;
+}>;
+export type DashboardResultKey<R extends AnyRegistry, Items extends readonly DashboardItem<R, string, string>[]> = DashboardItemResultKey<R, Extract<Items[number], DashboardWidgetItem<R>>>;
+export type DashboardState<R extends AnyRegistry, Items extends readonly DashboardItem<R, string, string>[]> = {
+    [TResultKey in DashboardResultKey<R, Items>]?: WidgetState<DashboardItemForResultKey<R, Items, TResultKey> extends {
+        key: infer TMetricKey extends InferAvailableMetricKey<R>;
+    } ? MetricOutputFor<R, TMetricKey> : never>;
+};
+export interface ChartMarker {
+    id: string;
+    timestamp: Date;
+    type: string;
+    label: string;
+    title: string;
+    description?: string;
+    severity?: 'info' | 'success' | 'warning' | 'danger';
+    icon?: string;
+    meta?: Record<string, unknown>;
+}
+export interface MarkerCategory {
+    type: string;
+    label: string;
+    count: number;
+    enabled: boolean;
+}
+export interface FrontendCatalogState<R extends AnyRegistry = AnyRegistry> {
+    metrics: AvailableMetricFor<R>[];
+    total: AvailableMetricsResult<R>['total'];
+}
+export {};

package/dist/frontend.d.ts

@@ -0,0 +1 @@
+export * from './frontend/index.ts';