react-semaphor 0.1.368 → 0.1.370

package/dist/types/data-app-sdk-validation.d.ts

@@ -27,6 +27,289 @@ declare type CalendarContext = {
     };
 };
 
+declare type MatrixAxisLevelDescriptor = {
+    instanceId: string;
+    fieldKey: string;
+    label: string;
+    field: SemaphorFieldRef;
+    grain?: SemaphorTimeGrain;
+    subtotal?: SemaphorMatrixSubtotalOptions;
+};
+
+declare type MatrixAxisPayload = {
+    id: 'rows' | 'columns';
+    levels: MatrixAxisLevelDescriptor[];
+    nodes: MatrixNode[];
+};
+
+declare type MatrixCapability = 'rowHierarchy' | 'columnHierarchy' | 'rowSubtotals' | 'columnSubtotals' | 'grandTotals' | 'lazyRows' | 'lazyColumns' | 'conditionalFormatting' | 'visualExport' | (string & {});
+
+declare type MatrixCell = {
+    id: string;
+    rowNodeId: string;
+    columnNodeId?: string;
+    measureInstanceId: string;
+    rowPath: MatrixMemberPathSegment[];
+    columnPath: MatrixMemberPathSegment[];
+    rawValue: unknown;
+    presence: MatrixCellPresence;
+    formattedValue?: string;
+    role: MatrixCellRole;
+    aggregateFunction?: SemaphorAggregateFunction;
+    formattingScope: MatrixCellFormattingScope;
+    actions?: MatrixCellAction[];
+};
+
+declare type MatrixCellAction = {
+    kind: 'requestSubgoal' | 'filter' | 'copyValue' | 'explainCalculation' | 'inspectContributingRows' | 'drillThrough' | (string & {});
+    label?: string;
+    payload?: Record<string, unknown>;
+};
+
+declare type MatrixCellFormattingScope = {
+    rowNodeId: string;
+    columnNodeId?: string;
+    measureInstanceId: string;
+    role: MatrixCellRole;
+    rowPath: MatrixMemberPathSegment[];
+    columnPath: MatrixMemberPathSegment[];
+};
+
+declare type MatrixCellPresence = 'present' | 'presentNull' | 'missing' | 'densified';
+
+declare type MatrixCellRole = 'value' | 'rowSubtotal' | 'columnSubtotal' | 'subtotalIntersection' | 'rowGrandTotal' | 'columnGrandTotal' | 'matrixGrandTotal';
+
+declare type MatrixExecutionMetadata = {
+    strategy?: MatrixQueryStrategy;
+    dialect?: SemaphorDialect;
+    rowNodeCount?: number;
+    columnNodeCount?: number;
+    cellCount?: number;
+    groupingSetCount?: number;
+    queryDurationMs?: number;
+    budgetRejected?: boolean;
+    cacheStatus?: 'hit' | 'miss' | 'bypass';
+    [key: string]: unknown;
+};
+
+declare type MatrixExpansionRequest = {
+    axis: 'row' | 'column';
+    path: MatrixMemberPathSegment[];
+    depth?: number;
+};
+
+declare type MatrixExpansionResponseHints = {
+    rowLazyLoading?: boolean;
+    columnLazyLoading?: boolean;
+    expandableRowNodeIds?: string[];
+    expandableColumnNodeIds?: string[];
+    nextRequests?: MatrixExpansionRequest[];
+};
+
+declare type MatrixFieldDescriptor = {
+    instanceId: string;
+    fieldKey: string;
+    field: SemaphorFieldRef;
+    role: 'row' | 'column' | 'measure' | 'sort' | 'filter';
+    label?: string;
+};
+
+declare type MatrixFieldDirectory = {
+    fieldsByInstanceId: Record<string, MatrixFieldDescriptor>;
+};
+
+declare type MatrixFormattingContext = {
+    domains?: Record<string, {
+        min?: number;
+        max?: number;
+    }>;
+    rules?: Array<Record<string, unknown>>;
+};
+
+declare type MatrixGridCell = {
+    id: string;
+    columnId: string;
+    cellId?: string;
+    rawValue: unknown;
+    formattedValue?: string;
+    presence: MatrixCellPresence;
+    role: MatrixCellRole;
+    measureInstanceId: string;
+    rowPath: MatrixMemberPathSegment[];
+    columnPath: MatrixMemberPathSegment[];
+};
+
+declare type MatrixGridColumn = {
+    id: string;
+    label: string;
+    columnNodeId?: string;
+    columnPath: MatrixMemberPathSegment[];
+    measureInstanceId: string;
+    role: 'value' | 'columnSubtotal' | 'columnGrandTotal';
+};
+
+declare type MatrixGridHeaderCell = {
+    id: string;
+    label: string;
+    role: 'rowHeader' | 'columnHeader' | 'measureHeader' | 'subtotal' | 'grandTotal';
+    colSpan: number;
+    rowSpan: number;
+    columnPath: MatrixMemberPathSegment[];
+    measureInstanceId?: string;
+};
+
+declare type MatrixGridHeaderRow = {
+    id: string;
+    cells: MatrixGridHeaderCell[];
+};
+
+declare type MatrixGridProjection = {
+    schemaVersion: 1;
+    shape: MatrixShape;
+    rowHeaderLevels: MatrixGridRowHeaderLevel[];
+    columnHeaderRows: MatrixGridHeaderRow[];
+    columns: MatrixGridColumn[];
+    rows: MatrixGridRow[];
+};
+
+declare type MatrixGridRow = {
+    id: string;
+    rowNodeId: string;
+    rowPath: MatrixMemberPathSegment[];
+    depth: number;
+    label: string;
+    role: 'value' | 'rowSubtotal' | 'rowGrandTotal';
+    isExpanded?: boolean;
+    hasChildren?: boolean;
+    cells: MatrixGridCell[];
+};
+
+declare type MatrixGridRowHeaderLevel = {
+    id: string;
+    label: string;
+    fieldInstanceId: string;
+};
+
+declare type MatrixMeasureDescriptor = {
+    instanceId: string;
+    fieldKey: string;
+    label: string;
+    field: SemaphorFieldRef;
+    aggregate?: SemaphorAggregateFunction;
+    totalBehavior?: SemaphorMatrixTotalCalculation;
+};
+
+declare type MatrixMeasureSemantics = {
+    kind: 'additive';
+    aggregate?: SemaphorAggregateFunction;
+} | {
+    kind: 'semiAdditive';
+    aggregate?: SemaphorAggregateFunction;
+    grain?: SemaphorTimeGrain;
+} | {
+    kind: 'nonAdditive';
+    aggregate?: SemaphorAggregateFunction;
+} | {
+    kind: 'ratio';
+    numeratorMeasureInstanceId?: string;
+    denominatorMeasureInstanceId?: string;
+} | {
+    kind: 'custom';
+    expressionId?: string;
+};
+
+declare type MatrixMemberPathSegment = {
+    instanceId: string;
+    fieldKey: string;
+    value: unknown;
+    label: string;
+};
+
+declare type MatrixNode = {
+    id: string;
+    axis: 'row' | 'column';
+    path: MatrixMemberPathSegment[];
+    level: number;
+    label: string;
+    value: unknown;
+    parentId?: string;
+    hasChildren: boolean;
+    isExpanded?: boolean;
+    isSubtotal?: boolean;
+    isGrandTotal?: boolean;
+    subtotalFunction?: SemaphorAggregateFunction;
+    childCount?: number;
+    actions?: MatrixNodeAction[];
+};
+
+declare type MatrixNodeAction = {
+    kind: 'expand' | 'collapse' | 'requestSubgoal' | 'filter' | 'drillThrough' | 'openRelatedRecords' | (string & {});
+    label?: string;
+    payload?: Record<string, unknown>;
+};
+
+declare type MatrixPageInfo = {
+    rowOffset?: number;
+    rowLimit?: number;
+    columnOffset?: number;
+    columnLimit?: number;
+    hasMoreRows?: boolean;
+    hasMoreColumns?: boolean;
+};
+
+declare type MatrixPayload = {
+    kind: 'matrixPayload';
+    schemaVersion: 1;
+    shape: MatrixShape;
+    capabilities: MatrixCapability[];
+    executionMetadata: MatrixExecutionMetadata;
+    axes: {
+        rows: MatrixAxisPayload;
+        columns: MatrixAxisPayload;
+    };
+    measures: MatrixMeasureDescriptor[];
+    measureSemantics: Record<string, MatrixMeasureSemantics>;
+    fieldDirectory: MatrixFieldDirectory;
+    rowNodes: MatrixNode[];
+    columnNodes: MatrixNode[];
+    cells: MatrixCell[];
+    totals: MatrixTotals;
+    sort: MatrixResolvedSort[];
+    formattingContext: MatrixFormattingContext;
+    pageInfo?: MatrixPageInfo;
+    warnings?: MatrixWarning[];
+};
+
+declare type MatrixQueryStrategy = 'tall' | 'wide' | 'lazy' | 'export';
+
+declare type MatrixResolvedSort = {
+    id: string;
+    axis: 'row' | 'column';
+    targetInstanceId?: string;
+    direction: 'asc' | 'desc';
+    nulls?: 'warehouseDefault' | 'first' | 'last';
+    scope?: 'global' | 'withinParent';
+    by: SemaphorMatrixSortRule['by'];
+};
+
+declare type MatrixShape = 'hierarchical' | 'pivot';
+
+declare type MatrixTotals = {
+    rows?: boolean;
+    columns?: boolean;
+    grandTotal?: boolean | {
+        rows?: boolean;
+        columns?: boolean;
+    };
+};
+
+declare type MatrixWarning = {
+    code: string;
+    message: string;
+    path?: string;
+    severity?: 'info' | 'warning' | 'error';
+};
+
 export declare function normalizeSemaphorAnalysisQueryOptions(value: unknown, options?: {
     pathPrefix?: string;
     validateTimezone?: SemaphorAnalysisTimezoneValidator;
@@ -51,6 +334,10 @@ declare type SemaphorAggregateFunction = 'SUM' | 'COUNT' | 'AVG' | 'MIN' | 'MAX'
 
 declare type SemaphorAnalysisDriverMode = 'absolute_delta' | 'largest_negative' | 'largest_positive' | 'positive_and_negative' | 'all';
 
+declare type SemaphorAnalysisQueryDefinition = SemaphorAnalysisQuerySpec & {
+    queryKind: 'analysis';
+};
+
 export declare type SemaphorAnalysisQueryOptions = {
     chartTitle?: string;
     chartType?: string;
@@ -124,7 +411,7 @@ declare type SemaphorAnalyticsFilterBase = {
 
 declare type SemaphorAnalyticsFilterOperator = SemaphorInputOperator | 'not_contains' | 'is_null' | 'is_not_null';
 
-declare type SemaphorAnalyticsIntent = SemaphorMetricIntent | SemaphorRecordsIntent | SemaphorInputOptionsIntent | SemaphorSqlIntent;
+declare type SemaphorAnalyticsIntent = SemaphorMetricIntent | SemaphorRecordsIntent | SemaphorInputOptionsIntent | SemaphorSqlIntent | SemaphorMatrixIntent;
 
 declare type SemaphorAnalyticsNullFilter = SemaphorAnalyticsFilterBase & {
     operator: SemaphorAnalyticsNullFilterOperator;
@@ -149,7 +436,7 @@ declare type SemaphorAnalyticsRepairHint = {
     recommendedNextStep: string;
 };
 
-declare type SemaphorAnalyticsResult = SemaphorMetricResult | SemaphorRecordsResult | SemaphorInputOptionsResult | SemaphorSqlResult;
+declare type SemaphorAnalyticsResult = SemaphorMetricResult | SemaphorRecordsResult | SemaphorInputOptionsResult | SemaphorSqlResult | SemaphorMatrixResult;
 
 declare type SemaphorAnalyticsResultBase = {
     intentId?: string;
@@ -158,6 +445,7 @@ declare type SemaphorAnalyticsResultBase = {
     rowCount?: number;
     rowLimitExceeded?: boolean;
     limit?: number;
+    pagination?: SemaphorPaginationMetadata;
 };
 
 declare type SemaphorAnalyticsValidationCode = 'missing_source' | 'invalid_source_kind' | 'missing_semantic_domain' | 'missing_dataset_name' | 'missing_connection_id' | 'missing_table_name' | 'missing_sql' | 'missing_metric' | 'missing_record_fields' | 'missing_input_options_field' | 'invalid_metric' | 'invalid_metric_list' | 'invalid_date_field' | 'invalid_dimension' | 'invalid_metric_dimensions' | 'conflicting_sql' | 'sql_policy_violation' | 'unsupported_intent_for_adapter' | 'invalid_analytics_kind' | 'invalid_analytics_intent';
@@ -209,6 +497,11 @@ declare type SemaphorCompiledQuery = {
     analyticsIntent?: SemaphorAnalyticsIntent;
 };
 
+declare type SemaphorControlInputSpec<TValue extends SemaphorInputValue = SemaphorInputValue> = SemaphorInputBase<TValue> & {
+    kind: 'control';
+    role: SemaphorControlRole;
+};
+
 declare type SemaphorControlRole = 'grain' | 'metric' | 'dimension' | 'aggregation' | 'sqlParam';
 
 export declare type SemaphorDataAppFieldCatalog = {
@@ -217,23 +510,14 @@ export declare type SemaphorDataAppFieldCatalog = {
     fields: SemaphorFieldRef[];
 };
 
-export declare type SemaphorDataAppHookSpec = {
-    hook: 'useSemaphorAnalysis';
-    spec: SemaphorAnalysisQuerySpec;
-} | {
-    hook: 'useSemaphorMetric';
-    spec: SemaphorMetricQuerySpec;
-} | {
-    hook: 'useSemaphorRecords';
-    spec: SemaphorRecordsQuerySpec;
-} | {
-    hook: 'useSemaphorInputOptions';
-    spec: SemaphorInputOptionsQuerySpec;
+export declare type SemaphorDataAppQuerySpecEnvelope = {
+    queryHook: 'useSemaphorQuery';
+    spec: SemaphorQueryDefinition;
 };
 
-export declare type SemaphorDataAppHookValidation = {
-    hook: SemaphorDataAppHookSpec['hook'];
-    hookId?: string;
+export declare type SemaphorDataAppQueryValidation = {
+    queryHook: SemaphorDataAppQuerySpecEnvelope['queryHook'];
+    queryId?: string;
     intent?: SemaphorAnalyticsIntent;
     diagnostics: SemaphorDataAppValidationDiagnostic[];
     executionResult: SemaphorAnalyticsExecutionResult;
@@ -241,11 +525,11 @@ export declare type SemaphorDataAppHookValidation = {
 
 export declare type SemaphorDataAppValidationDiagnostic = {
     severity: 'error' | 'warning';
-    code: 'invalid_hook_spec' | 'invalid_analytics_intent' | 'invalid_source_ref' | 'missing_field' | 'unsupported_input_filter_composition' | string;
+    code: 'invalid_query_spec' | 'invalid_analytics_intent' | 'invalid_source_ref' | 'missing_field' | 'unsupported_input_filter_composition' | string;
     message: string;
     path?: string;
-    hook?: SemaphorDataAppHookSpec['hook'];
-    hookId?: string;
+    queryHook?: SemaphorDataAppQuerySpecEnvelope['queryHook'];
+    queryId?: string;
     intentId?: string;
     source?: SemaphorSourceRef;
     field?: SemaphorFieldRef;
@@ -254,7 +538,7 @@ export declare type SemaphorDataAppValidationDiagnostic = {
 export declare type SemaphorDataAppValidationResult = {
     ok: boolean;
     diagnostics: SemaphorDataAppValidationDiagnostic[];
-    hooks: SemaphorDataAppHookValidation[];
+    queries: SemaphorDataAppQueryValidation[];
     intents: SemaphorAnalyticsIntent[];
     executionResults: SemaphorAnalyticsExecutionResult[];
 };
@@ -267,6 +551,14 @@ declare type SemaphorExecutionFieldRef = SemaphorFieldRef & {
     aggregateSource?: SemaphorMetricAggregateSource;
 };
 
+/**
+ * Explorer-backed table source. This is intentionally distinct from raw SQL:
+ * matrix planning needs stable source metadata, fields, and dialect context.
+ */
+declare type SemaphorExplorerSourceRef = Extract<SemaphorSourceRef, {
+    kind: 'physical';
+}>;
+
 declare type SemaphorFieldRef = {
     name: string;
     label?: string;
@@ -276,8 +568,29 @@ declare type SemaphorFieldRef = {
     aggregate?: SemaphorAggregateFunction;
 };
 
+declare type SemaphorFilterInputSpec<TValue extends SemaphorInputValue = SemaphorInputValue> = SemaphorInputBase<TValue> & {
+    kind: 'filter';
+    field: SemaphorQueryField;
+    operator?: SemaphorInputOperatorInput;
+    multi?: boolean;
+};
+
+declare type SemaphorInputBase<TValue extends SemaphorInputValue> = {
+    id: string;
+    label?: string;
+    value?: TValue;
+    defaultValue?: TValue;
+    onValueChange?: {
+        bivarianceHack(value: TValue | undefined): void;
+    }['bivarianceHack'];
+    options?: Array<SemaphorInputOption | SemaphorOptionValue>;
+};
+
 declare type SemaphorInputBinding = {
     inputId: string;
+    kind?: 'filter' | 'control';
+    controlRole?: 'grain' | 'metric' | 'dimension' | 'aggregation' | 'sqlParam';
+    operator?: SemaphorInputOperator;
     field?: SemaphorFieldRef;
 };
 
@@ -298,6 +611,10 @@ declare type SemaphorInputHandle<TValue extends SemaphorInputValue = SemaphorInp
 
 declare type SemaphorInputOperator = '=' | '!=' | 'in' | 'not_in' | 'contains' | 'not_contains' | 'between' | 'not_between' | '>' | '>=' | '<' | '<=';
 
+declare type SemaphorInputOperatorAlias = 'eq' | 'equals' | 'not_equals' | 'neq' | 'not equal' | 'not equals' | 'not in' | 'like' | 'not_contains' | 'not contains' | 'not_like' | 'not like' | 'not_between' | 'not between';
+
+declare type SemaphorInputOperatorInput = SemaphorInputOperator | SemaphorInputOperatorAlias;
+
 declare type SemaphorInputOption = {
     label: string;
     value: SemaphorOptionValue;
@@ -315,6 +632,10 @@ declare type SemaphorInputOptionsIntent = {
     limit?: number;
 };
 
+declare type SemaphorInputOptionsQueryDefinition = SemaphorInputOptionsQuerySpec & {
+    queryKind: 'inputOptions';
+};
+
 declare type SemaphorInputOptionsQuerySpec = SemaphorQuerySourceSpec & {
     id?: string;
     label?: string;
@@ -332,10 +653,184 @@ declare type SemaphorInputOptionsResult = SemaphorAnalyticsResultBase & {
     }>;
 };
 
-declare type SemaphorInputReference = SemaphorInputBinding | SemaphorActiveInput | SemaphorInputHandle;
+declare type SemaphorInputReference = SemaphorInputSpec | SemaphorInputBinding | SemaphorActiveInput | SemaphorInputHandle;
+
+declare type SemaphorInputSpec<TValue extends SemaphorInputValue = SemaphorInputValue> = SemaphorFilterInputSpec<TValue> | SemaphorControlInputSpec<TValue>;
 
 declare type SemaphorInputValue = SemaphorScalar | SemaphorScalar[];
 
+declare type SemaphorMatrixAxisExpansionOptions = {
+    defaultDepth?: number;
+    lazy?: boolean;
+    expandedPaths?: SemaphorMatrixMemberPathSegment[][];
+};
+
+declare type SemaphorMatrixAxisLevel = {
+    id?: string;
+    field: SemaphorFieldRef;
+    grain?: SemaphorTimeGrain;
+    label?: string;
+    subtotal?: boolean | SemaphorMatrixSubtotalOptions;
+    sortBy?: SemaphorMatrixAxisSortRule;
+};
+
+declare type SemaphorMatrixAxisLevelInput = SemaphorQueryField | SemaphorMatrixAxisLevel;
+
+declare type SemaphorMatrixAxisSortRule = {
+    direction: 'asc' | 'desc';
+    by: {
+        kind: 'label';
+    } | {
+        kind: 'field';
+        field: SemaphorFieldRef;
+        aggregate?: SemaphorAggregateFunction;
+    };
+    nulls?: 'warehouseDefault' | 'first' | 'last';
+    scope?: 'global' | 'withinParent';
+};
+
+declare type SemaphorMatrixDisplayLimitOptions = {
+    rows?: SemaphorMatrixDisplayLimitRule;
+    columns?: SemaphorMatrixDisplayLimitRule;
+};
+
+declare type SemaphorMatrixDisplayLimitRule = {
+    limit: number;
+    by?: 'label' | 'value';
+    direction?: 'top' | 'bottom';
+    others?: boolean | {
+        label?: string;
+    };
+};
+
+declare type SemaphorMatrixExpansionOptions = {
+    rows?: SemaphorMatrixAxisExpansionOptions;
+    columns?: SemaphorMatrixAxisExpansionOptions;
+};
+
+declare type SemaphorMatrixIntent = {
+    kind: 'matrix';
+    version?: SemaphorProtocolVersion;
+    id?: string;
+    label?: string;
+    source: SemaphorMatrixSourceRef;
+    rows: SemaphorMatrixAxisLevel[];
+    columns?: SemaphorMatrixAxisLevel[];
+    values: SemaphorMatrixValueField[];
+    filters?: SemaphorAnalyticsFilter[];
+    inputs?: SemaphorInputBinding[];
+    totals?: SemaphorMatrixTotalOptions;
+    sort?: SemaphorMatrixSortRule[];
+    expansion?: SemaphorMatrixExpansionOptions;
+    layout?: SemaphorMatrixLayoutOptions;
+    displayLimits?: SemaphorMatrixDisplayLimitOptions;
+};
+
+declare type SemaphorMatrixLayoutOptions = {
+    hierarchy?: 'compact' | 'tabular' | 'outline';
+    valuesPlacement?: 'columns' | 'rows';
+    stickyRowHeaders?: boolean;
+    stickyColumnHeaders?: boolean;
+};
+
+declare type SemaphorMatrixMemberPathSegment = {
+    levelId: string;
+    value: unknown;
+};
+
+declare type SemaphorMatrixQueryDefinition = SemaphorMatrixQuerySpec & {
+    queryKind: 'matrix';
+};
+
+declare type SemaphorMatrixQuerySpec = Omit<SemaphorMatrixIntent, 'kind' | 'version' | 'rows' | 'columns' | 'values' | 'source' | 'inputs'> & {
+    source: SemaphorMatrixSourceRef;
+    rows: SemaphorNonEmptyArray<SemaphorMatrixAxisLevelInput>;
+    columns?: SemaphorMatrixAxisLevelInput[];
+    values: SemaphorNonEmptyArray<SemaphorMatrixValueFieldInput>;
+    inputs?: SemaphorInputReference[];
+    totals?: SemaphorMatrixTotalOptions;
+    sort?: SemaphorMatrixSortRule[];
+    expansion?: SemaphorMatrixExpansionOptions;
+    layout?: SemaphorMatrixIntent['layout'];
+    displayLimits?: SemaphorMatrixDisplayLimitOptions;
+};
+
+declare type SemaphorMatrixResult = SemaphorAnalyticsResultBase & {
+    kind: 'matrix';
+    intent: SemaphorMatrixIntent;
+    payload: MatrixPayload;
+    grid: MatrixGridProjection;
+    expansion?: MatrixExpansionResponseHints;
+};
+
+declare type SemaphorMatrixSortRule = {
+    axis: 'row' | 'column';
+    targetId?: string;
+    direction: 'asc' | 'desc';
+    by: {
+        kind: 'label';
+    } | {
+        kind: 'field';
+        field: SemaphorFieldRef;
+        aggregate?: SemaphorAggregateFunction;
+    } | {
+        kind: 'value';
+        valueId: string;
+        rowPath?: SemaphorMatrixMemberPathSegment[];
+        columnPath?: SemaphorMatrixMemberPathSegment[];
+    };
+    nulls?: 'warehouseDefault' | 'first' | 'last';
+    scope?: 'global' | 'withinParent';
+};
+
+declare type SemaphorMatrixSourceRef = SemaphorSemanticSourceRef | SemaphorExplorerSourceRef;
+
+declare type SemaphorMatrixSubtotalOptions = {
+    enabled?: boolean;
+    position?: 'before' | 'after';
+    label?: string;
+};
+
+declare type SemaphorMatrixTotalCalculation = {
+    kind: 'defaultAggregate';
+} | {
+    kind: 'blank';
+} | {
+    kind: 'labelOnly';
+    label?: string;
+} | {
+    kind: 'customAggregate';
+    aggregate: SemaphorAggregateFunction;
+} | {
+    kind: 'percentOfParent';
+} | {
+    kind: 'percentOfGrandTotal';
+} | {
+    kind: 'customExpression';
+    expressionId: string;
+};
+
+declare type SemaphorMatrixTotalOptions = {
+    rows?: boolean | 'perLevel';
+    columns?: boolean | 'perLevel';
+    grandTotal?: boolean | {
+        rows?: boolean;
+        columns?: boolean;
+    };
+    rowPosition?: 'top' | 'bottom';
+    columnPosition?: 'left' | 'right';
+};
+
+declare type SemaphorMatrixValueField = {
+    id?: string;
+    field: SemaphorFieldRef;
+    aggregate?: SemaphorAggregateFunction;
+    label?: string;
+    totalBehavior?: SemaphorMatrixTotalCalculation;
+};
+
+declare type SemaphorMatrixValueFieldInput = SemaphorQueryField | SemaphorMatrixValueField;
+
 declare type SemaphorMetricAggregateSource = 'semantic_model' | 'caller_override' | 'default_sum';
 
 declare type SemaphorMetricAnalysis = {
@@ -376,6 +871,10 @@ declare type SemaphorMetricIntent = {
     limit?: number;
 };
 
+declare type SemaphorMetricQueryDefinition = SemaphorMetricQuerySpec & {
+    queryKind: 'metric';
+};
+
 declare type SemaphorMetricQuerySpec = SemaphorQuerySourceSpec & {
     id?: string;
     label?: string;
@@ -405,6 +904,20 @@ declare type SemaphorNonEmptyArray<T> = [T, ...T[]];
 
 declare type SemaphorOptionValue = string | number | boolean;
 
+declare type SemaphorPaginationMetadata = {
+    page: number;
+    pageSize: number;
+    pageCount: number;
+    totalCount: number;
+    hasNextPage: boolean;
+    hasPrevPage: boolean;
+};
+
+declare type SemaphorPaginationRequest = {
+    page: number;
+    pageSize: number;
+};
+
 declare type SemaphorProtocolIssue = {
     code: string;
     message: string;
@@ -413,6 +926,8 @@ declare type SemaphorProtocolIssue = {
 
 declare type SemaphorProtocolVersion = 1;
 
+declare type SemaphorQueryDefinition = SemaphorMetricQueryDefinition | SemaphorAnalysisQueryDefinition | SemaphorRecordsQueryDefinition | SemaphorInputOptionsQueryDefinition | SemaphorSqlQueryDefinition | SemaphorMatrixQueryDefinition;
+
 declare type SemaphorQueryField = SemaphorFieldRef;
 
 declare type SemaphorQueryOrderBy = {
@@ -436,6 +951,7 @@ declare type SemaphorRecordsBaseQuerySpec = SemaphorQuerySourceSpec & {
     orderBy?: SemaphorRecordsOrderBy;
     inputs?: SemaphorInputReference[];
     limit?: number;
+    pagination?: SemaphorPaginationRequest;
 };
 
 declare type SemaphorRecordsField = SemaphorFieldRef & {
@@ -454,6 +970,7 @@ declare type SemaphorRecordsIntent = {
     timeWindow?: SemaphorTimeWindow;
     filters?: SemaphorAnalyticsFilter[];
     limit?: number;
+    pagination?: SemaphorPaginationRequest;
     orderBy?: {
         field: SemaphorFieldRef;
         direction: 'asc' | 'desc';
@@ -463,6 +980,10 @@ declare type SemaphorRecordsIntent = {
 
 declare type SemaphorRecordsOrderBy = SemaphorQueryOrderBy;
 
+declare type SemaphorRecordsQueryDefinition = SemaphorRecordsQuerySpec & {
+    queryKind: 'records';
+};
+
 declare type SemaphorRecordsQuerySpec = SemaphorRecordsBaseQuerySpec & SemaphorRecordsSelectorSpec;
 
 declare type SemaphorRecordsResult = SemaphorAnalyticsResultBase & {
@@ -526,6 +1047,10 @@ declare type SemaphorResultColumn = {
 
 declare type SemaphorScalar = string | number | boolean | null;
 
+declare type SemaphorSemanticSourceRef = Extract<SemaphorSourceRef, {
+    kind: 'semantic';
+}>;
+
 declare type SemaphorSourceRef = {
     kind: 'semantic';
     domainId: string;
@@ -558,14 +1083,34 @@ declare type SemaphorSqlIntent = {
         kind: 'sql';
     }>;
     sql: string;
-    parameters?: Record<string, unknown>;
+    defaultParameters?: Record<string, unknown>;
     pythonCode?: string;
     limit?: number;
+    pagination?: SemaphorPaginationRequest;
     rationale?: string;
     fields?: SemaphorFieldRef[];
     inputs?: SemaphorInputBinding[];
 };
 
+declare type SemaphorSqlParameterValue = SemaphorScalar | SemaphorScalar[];
+
+declare type SemaphorSqlQueryDefinition = SemaphorSqlQuerySpec & {
+    queryKind: 'sql';
+};
+
+declare type SemaphorSqlQuerySpec = SemaphorSqlSourceSpec & {
+    id?: string;
+    label?: string;
+    sql: string;
+    defaultParameters?: Record<string, SemaphorSqlParameterValue>;
+    pythonCode?: string;
+    fields?: SemaphorFieldRef[];
+    inputs?: SemaphorInputReference[];
+    limit?: number;
+    pagination?: SemaphorPaginationRequest;
+    rationale?: string;
+};
+
 declare type SemaphorSqlResult = SemaphorAnalyticsResultBase & {
     kind: 'sql';
     columns: SemaphorRecordsResult['columns'];
@@ -577,12 +1122,18 @@ declare type SemaphorSqlResult = SemaphorAnalyticsResultBase & {
     };
 };
 
+declare type SemaphorSqlSourceSpec = {
+    source: Extract<SemaphorSourceRef, {
+        kind: 'sql';
+    }>;
+};
+
 declare type SemaphorTimeGrain = 'hour' | 'day' | 'week' | 'month' | 'quarter' | 'year';
 
 declare type SemaphorTimeWindow = SemaphorRelativeTimeWindow | SemaphorAbsoluteTimeWindow;
 
-export declare function validateSemaphorDataAppHookSpecs(input: {
-    hooks: SemaphorDataAppHookSpec[];
+export declare function validateSemaphorDataAppQuerySpecs(input: {
+    queries: SemaphorDataAppQuerySpecEnvelope[];
     fieldCatalogs?: SemaphorDataAppFieldCatalog[];
     requireFieldCatalog?: boolean;
     validateTimezone?: SemaphorAnalysisTimezoneValidator;