react-semaphor 0.1.504 → 0.1.505

package/dist/types/shared/analytics-protocol/matrix-operation-contract.d.ts

@@ -0,0 +1,759 @@
+import { z } from 'zod';
+import { analyticsExecutionEnvelopeSchema } from './runtime-schemas.js';
+export { matrixOperationRequestSchema, type MatrixOperationRequest } from './matrix-operation-request.js';
+export { matrixAnalyticalIntentSchema } from './matrix-definition-contract.js';
+/** Session constraints are separate from the authored definition and applied once. */
+export declare const matrixRuntimeInputsSchema: z.ZodObject<{
+    runtimeFilters: z.ZodOptional<z.ZodType<import('../../components/index.js').FilterGroup, z.ZodTypeDef, import('../../components/index.js').FilterGroup>>;
+    runtimeSorts: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        axis: z.ZodEnum<["rows", "columns"]>;
+        levelId: z.ZodString;
+        scope: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
+            kind: z.ZodLiteral<"level">;
+        }, "strict", z.ZodTypeAny, {
+            kind: "level";
+        }, {
+            kind: "level";
+        }>, z.ZodObject<{
+            kind: z.ZodLiteral<"branch">;
+            parent: z.ZodType<import('./matrix-path-contract.js').MatrixPath>;
+        }, "strict", z.ZodTypeAny, {
+            kind: "branch";
+            parent: readonly {
+                member: {
+                    value: string | number | boolean | {
+                        value: string;
+                        type: "integer" | "decimal";
+                        kind: "exact_number";
+                    } | null;
+                    kind: "value";
+                } | {
+                    kind: "others";
+                    rankingId: string;
+                };
+                levelId: string;
+            }[];
+        }, {
+            kind: "branch";
+            parent: readonly {
+                member: {
+                    value: string | number | boolean | {
+                        value: string;
+                        type: "integer" | "decimal";
+                        kind: "exact_number";
+                    } | null;
+                    kind: "value";
+                } | {
+                    kind: "others";
+                    rankingId: string;
+                };
+                levelId: string;
+            }[];
+        }>]>;
+        target: z.ZodType<import('./matrix-definition-contract.js').MatrixSortTarget, z.ZodTypeDef, import('./matrix-definition-contract.js').MatrixSortTarget>;
+        direction: z.ZodEnum<["asc", "desc"]>;
+        nulls: z.ZodEnum<["first", "last"]>;
+    }, "strict", z.ZodTypeAny, {
+        target: import('./matrix-definition-contract.js').MatrixSortTarget;
+        scope: {
+            kind: "level";
+        } | {
+            kind: "branch";
+            parent: readonly {
+                member: {
+                    value: string | number | boolean | {
+                        value: string;
+                        type: "integer" | "decimal";
+                        kind: "exact_number";
+                    } | null;
+                    kind: "value";
+                } | {
+                    kind: "others";
+                    rankingId: string;
+                };
+                levelId: string;
+            }[];
+        };
+        levelId: string;
+        axis: "columns" | "rows";
+        direction: "asc" | "desc";
+        nulls: "first" | "last";
+    }, {
+        target: import('./matrix-definition-contract.js').MatrixSortTarget;
+        scope: {
+            kind: "level";
+        } | {
+            kind: "branch";
+            parent: readonly {
+                member: {
+                    value: string | number | boolean | {
+                        value: string;
+                        type: "integer" | "decimal";
+                        kind: "exact_number";
+                    } | null;
+                    kind: "value";
+                } | {
+                    kind: "others";
+                    rankingId: string;
+                };
+                levelId: string;
+            }[];
+        };
+        levelId: string;
+        axis: "columns" | "rows";
+        direction: "asc" | "desc";
+        nulls: "first" | "last";
+    }>, "many">>>;
+}, "strip", z.ZodTypeAny, {
+    runtimeSorts?: readonly {
+        target: import('./matrix-definition-contract.js').MatrixSortTarget;
+        scope: {
+            kind: "level";
+        } | {
+            kind: "branch";
+            parent: readonly {
+                member: {
+                    value: string | number | boolean | {
+                        value: string;
+                        type: "integer" | "decimal";
+                        kind: "exact_number";
+                    } | null;
+                    kind: "value";
+                } | {
+                    kind: "others";
+                    rankingId: string;
+                };
+                levelId: string;
+            }[];
+        };
+        levelId: string;
+        axis: "columns" | "rows";
+        direction: "asc" | "desc";
+        nulls: "first" | "last";
+    }[] | undefined;
+    runtimeFilters?: import('../../components/index.js').FilterGroup | undefined;
+}, {
+    runtimeSorts?: readonly {
+        target: import('./matrix-definition-contract.js').MatrixSortTarget;
+        scope: {
+            kind: "level";
+        } | {
+            kind: "branch";
+            parent: readonly {
+                member: {
+                    value: string | number | boolean | {
+                        value: string;
+                        type: "integer" | "decimal";
+                        kind: "exact_number";
+                    } | null;
+                    kind: "value";
+                } | {
+                    kind: "others";
+                    rankingId: string;
+                };
+                levelId: string;
+            }[];
+        };
+        levelId: string;
+        axis: "columns" | "rows";
+        direction: "asc" | "desc";
+        nulls: "first" | "last";
+    }[] | undefined;
+    runtimeFilters?: import('../../components/index.js').FilterGroup | undefined;
+}>;
+export type MatrixRuntimeInputs = z.infer<typeof matrixRuntimeInputsSchema>;
+export declare function parseMatrixRuntimeInputs(input: unknown): MatrixRuntimeInputs;
+/** Derive common governance fields; never construct an MCP-only result envelope. */
+declare const matrixExecutionShape: {
+    compiledQuery: z.ZodOptional<z.ZodNever>;
+    intent: z.ZodEffects<z.ZodObject<{
+        source: z.ZodUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"semantic">;
+            datasetId: z.ZodOptional<z.ZodString>;
+            label: z.ZodOptional<z.ZodString>;
+            connectionId: z.ZodOptional<z.ZodString>;
+        } & {
+            domainId: z.ZodEffects<z.ZodString, string, string>;
+            datasetName: z.ZodEffects<z.ZodString, string, string>;
+        }, "strict", z.ZodTypeAny, {
+            kind: "semantic";
+            domainId: string;
+            datasetName: string;
+            datasetId?: string | undefined;
+            label?: string | undefined;
+            connectionId?: string | undefined;
+        }, {
+            kind: "semantic";
+            domainId: string;
+            datasetName: string;
+            datasetId?: string | undefined;
+            label?: string | undefined;
+            connectionId?: string | undefined;
+        }>, z.ZodObject<{
+            kind: z.ZodLiteral<"physical">;
+            connectionType: z.ZodOptional<z.ZodString>;
+            databaseName: z.ZodOptional<z.ZodString>;
+            schemaName: z.ZodOptional<z.ZodString>;
+            label: z.ZodOptional<z.ZodString>;
+            dialect: z.ZodOptional<z.ZodEnum<["postgres", "mysql", "mssql", "snowflake", "clickhouse", "bigquery", "redshift", "duckdb", "sqlite", "unknown"]>>;
+        } & {
+            connectionId: z.ZodEffects<z.ZodString, string, string>;
+            tableName: z.ZodEffects<z.ZodString, string, string>;
+        }, "strict", z.ZodTypeAny, {
+            kind: "physical";
+            connectionId: string;
+            tableName: string;
+            label?: string | undefined;
+            connectionType?: string | undefined;
+            databaseName?: string | undefined;
+            schemaName?: string | undefined;
+            dialect?: "postgres" | "mysql" | "mssql" | "snowflake" | "clickhouse" | "bigquery" | "redshift" | "duckdb" | "sqlite" | "unknown" | undefined;
+        }, {
+            kind: "physical";
+            connectionId: string;
+            tableName: string;
+            label?: string | undefined;
+            connectionType?: string | undefined;
+            databaseName?: string | undefined;
+            schemaName?: string | undefined;
+            dialect?: "postgres" | "mysql" | "mssql" | "snowflake" | "clickhouse" | "bigquery" | "redshift" | "duckdb" | "sqlite" | "unknown" | undefined;
+        }>]>;
+        rows: z.ZodReadonly<z.ZodArray<z.ZodType<import('./matrix-definition-contract.js').MatrixLevel, z.ZodTypeDef, import('./matrix-definition-contract.js').MatrixLevel>, "many">>;
+        columns: z.ZodReadonly<z.ZodArray<z.ZodType<import('./matrix-definition-contract.js').MatrixLevel, z.ZodTypeDef, import('./matrix-definition-contract.js').MatrixLevel>, "many">>;
+        measures: z.ZodReadonly<z.ZodArray<z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
+            id: z.ZodString;
+            kind: z.ZodLiteral<"aggregate">;
+            field: z.ZodType<import('./matrix-definition-contract.js').MatrixField, z.ZodTypeDef, import('./matrix-definition-contract.js').MatrixField>;
+            aggregate: z.ZodEnum<["SUM", "COUNT", "DISTINCT", "AVG", "MIN", "MAX"]>;
+        }, "strict", z.ZodTypeAny, {
+            id: string;
+            kind: "aggregate";
+            aggregate: "SUM" | "COUNT" | "AVG" | "MIN" | "MAX" | "DISTINCT";
+            field: Omit<import('./contracts.js').SemaphorExecutionFieldRef, "source" | "aggregate" | "derivedField"> & {
+                source?: import('./contracts.js').SemaphorMatrixSourceRef;
+                derivedField?: Omit<import('./contracts.js').SemaphorDerivedFieldDefinition, "inputs"> & {
+                    inputs: Record<string, {
+                        kind: "field";
+                        field: Omit<import('./contracts.js').SemaphorFieldRef, "source"> & {
+                            source?: import('./contracts.js').SemaphorMatrixSourceRef;
+                        };
+                        aggregate?: import('./contracts.js').SemaphorAggregateFunction;
+                    }>;
+                };
+            };
+        }, {
+            id: string;
+            kind: "aggregate";
+            aggregate: "SUM" | "COUNT" | "AVG" | "MIN" | "MAX" | "DISTINCT";
+            field: Omit<import('./contracts.js').SemaphorExecutionFieldRef, "source" | "aggregate" | "derivedField"> & {
+                source?: import('./contracts.js').SemaphorMatrixSourceRef;
+                derivedField?: Omit<import('./contracts.js').SemaphorDerivedFieldDefinition, "inputs"> & {
+                    inputs: Record<string, {
+                        kind: "field";
+                        field: Omit<import('./contracts.js').SemaphorFieldRef, "source"> & {
+                            source?: import('./contracts.js').SemaphorMatrixSourceRef;
+                        };
+                        aggregate?: import('./contracts.js').SemaphorAggregateFunction;
+                    }>;
+                };
+            };
+        }>, z.ZodObject<{
+            id: z.ZodString;
+            kind: z.ZodLiteral<"calculated">;
+            definition: z.ZodType<Omit<import('./contracts.js').SemaphorDerivedFieldDefinition, "inputs"> & {
+                inputs: Record<string, {
+                    kind: "field";
+                    field: Omit<import('./contracts.js').SemaphorFieldRef, "source"> & {
+                        source?: import('./contracts.js').SemaphorMatrixSourceRef;
+                    };
+                    aggregate?: import('./contracts.js').SemaphorAggregateFunction;
+                }>;
+            }>;
+        }, "strict", z.ZodTypeAny, {
+            id: string;
+            kind: "calculated";
+            definition: Omit<import('./contracts.js').SemaphorDerivedFieldDefinition, "inputs"> & {
+                inputs: Record<string, {
+                    kind: "field";
+                    field: Omit<import('./contracts.js').SemaphorFieldRef, "source"> & {
+                        source?: import('./contracts.js').SemaphorMatrixSourceRef;
+                    };
+                    aggregate?: import('./contracts.js').SemaphorAggregateFunction;
+                }>;
+            };
+        }, {
+            id: string;
+            kind: "calculated";
+            definition: Omit<import('./contracts.js').SemaphorDerivedFieldDefinition, "inputs"> & {
+                inputs: Record<string, {
+                    kind: "field";
+                    field: Omit<import('./contracts.js').SemaphorFieldRef, "source"> & {
+                        source?: import('./contracts.js').SemaphorMatrixSourceRef;
+                    };
+                    aggregate?: import('./contracts.js').SemaphorAggregateFunction;
+                }>;
+            };
+        }>]>, "many">>;
+        filters: z.ZodOptional<z.ZodType<import('../../components/index.js').FilterGroup, z.ZodTypeDef, import('../../components/index.js').FilterGroup>>;
+        joinPlan: z.ZodOptional<z.ZodType<import('../../components/index.js').JoinPlan, z.ZodTypeDef, import('../../components/index.js').JoinPlan>>;
+        relationshipHint: z.ZodOptional<z.ZodObject<{
+            relationshipIds: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        }, "strict", z.ZodTypeAny, {
+            relationshipIds?: string[] | undefined;
+        }, {
+            relationshipIds?: string[] | undefined;
+        }>>;
+        sorts: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+            axis: z.ZodEnum<["rows", "columns"]>;
+            levelId: z.ZodString;
+            scope: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
+                kind: z.ZodLiteral<"level">;
+            }, "strict", z.ZodTypeAny, {
+                kind: "level";
+            }, {
+                kind: "level";
+            }>, z.ZodObject<{
+                kind: z.ZodLiteral<"branch">;
+                parent: z.ZodType<import('./matrix-path-contract.js').MatrixPath>;
+            }, "strict", z.ZodTypeAny, {
+                kind: "branch";
+                parent: readonly {
+                    member: {
+                        value: string | number | boolean | {
+                            value: string;
+                            type: "integer" | "decimal";
+                            kind: "exact_number";
+                        } | null;
+                        kind: "value";
+                    } | {
+                        kind: "others";
+                        rankingId: string;
+                    };
+                    levelId: string;
+                }[];
+            }, {
+                kind: "branch";
+                parent: readonly {
+                    member: {
+                        value: string | number | boolean | {
+                            value: string;
+                            type: "integer" | "decimal";
+                            kind: "exact_number";
+                        } | null;
+                        kind: "value";
+                    } | {
+                        kind: "others";
+                        rankingId: string;
+                    };
+                    levelId: string;
+                }[];
+            }>]>;
+            target: z.ZodType<import('./matrix-definition-contract.js').MatrixSortTarget, z.ZodTypeDef, import('./matrix-definition-contract.js').MatrixSortTarget>;
+            direction: z.ZodEnum<["asc", "desc"]>;
+            nulls: z.ZodEnum<["first", "last"]>;
+        }, "strict", z.ZodTypeAny, {
+            target: import('./matrix-definition-contract.js').MatrixSortTarget;
+            scope: {
+                kind: "level";
+            } | {
+                kind: "branch";
+                parent: readonly {
+                    member: {
+                        value: string | number | boolean | {
+                            value: string;
+                            type: "integer" | "decimal";
+                            kind: "exact_number";
+                        } | null;
+                        kind: "value";
+                    } | {
+                        kind: "others";
+                        rankingId: string;
+                    };
+                    levelId: string;
+                }[];
+            };
+            levelId: string;
+            axis: "columns" | "rows";
+            direction: "asc" | "desc";
+            nulls: "first" | "last";
+        }, {
+            target: import('./matrix-definition-contract.js').MatrixSortTarget;
+            scope: {
+                kind: "level";
+            } | {
+                kind: "branch";
+                parent: readonly {
+                    member: {
+                        value: string | number | boolean | {
+                            value: string;
+                            type: "integer" | "decimal";
+                            kind: "exact_number";
+                        } | null;
+                        kind: "value";
+                    } | {
+                        kind: "others";
+                        rankingId: string;
+                    };
+                    levelId: string;
+                }[];
+            };
+            levelId: string;
+            axis: "columns" | "rows";
+            direction: "asc" | "desc";
+            nulls: "first" | "last";
+        }>, "many">>;
+        rankings: z.ZodReadonly<z.ZodArray<z.ZodType<import('./matrix-definition-contract.js').MatrixRanking, z.ZodTypeDef, import('./matrix-definition-contract.js').MatrixRanking>, "many">>;
+    } & {
+        kind: z.ZodLiteral<"matrix">;
+    }, "strict", z.ZodTypeAny, {
+        kind: "matrix";
+        source: {
+            kind: "semantic";
+            domainId: string;
+            datasetName: string;
+            datasetId?: string | undefined;
+            label?: string | undefined;
+            connectionId?: string | undefined;
+        } | {
+            kind: "physical";
+            connectionId: string;
+            tableName: string;
+            label?: string | undefined;
+            connectionType?: string | undefined;
+            databaseName?: string | undefined;
+            schemaName?: string | undefined;
+            dialect?: "postgres" | "mysql" | "mssql" | "snowflake" | "clickhouse" | "bigquery" | "redshift" | "duckdb" | "sqlite" | "unknown" | undefined;
+        };
+        columns: readonly import('./matrix-definition-contract.js').MatrixLevel[];
+        measures: readonly ({
+            id: string;
+            kind: "aggregate";
+            aggregate: "SUM" | "COUNT" | "AVG" | "MIN" | "MAX" | "DISTINCT";
+            field: Omit<import('./contracts.js').SemaphorExecutionFieldRef, "source" | "aggregate" | "derivedField"> & {
+                source?: import('./contracts.js').SemaphorMatrixSourceRef;
+                derivedField?: Omit<import('./contracts.js').SemaphorDerivedFieldDefinition, "inputs"> & {
+                    inputs: Record<string, {
+                        kind: "field";
+                        field: Omit<import('./contracts.js').SemaphorFieldRef, "source"> & {
+                            source?: import('./contracts.js').SemaphorMatrixSourceRef;
+                        };
+                        aggregate?: import('./contracts.js').SemaphorAggregateFunction;
+                    }>;
+                };
+            };
+        } | {
+            id: string;
+            kind: "calculated";
+            definition: Omit<import('./contracts.js').SemaphorDerivedFieldDefinition, "inputs"> & {
+                inputs: Record<string, {
+                    kind: "field";
+                    field: Omit<import('./contracts.js').SemaphorFieldRef, "source"> & {
+                        source?: import('./contracts.js').SemaphorMatrixSourceRef;
+                    };
+                    aggregate?: import('./contracts.js').SemaphorAggregateFunction;
+                }>;
+            };
+        })[];
+        rows: readonly import('./matrix-definition-contract.js').MatrixLevel[];
+        sorts: readonly {
+            target: import('./matrix-definition-contract.js').MatrixSortTarget;
+            scope: {
+                kind: "level";
+            } | {
+                kind: "branch";
+                parent: readonly {
+                    member: {
+                        value: string | number | boolean | {
+                            value: string;
+                            type: "integer" | "decimal";
+                            kind: "exact_number";
+                        } | null;
+                        kind: "value";
+                    } | {
+                        kind: "others";
+                        rankingId: string;
+                    };
+                    levelId: string;
+                }[];
+            };
+            levelId: string;
+            axis: "columns" | "rows";
+            direction: "asc" | "desc";
+            nulls: "first" | "last";
+        }[];
+        rankings: readonly import('./matrix-definition-contract.js').MatrixRanking[];
+        filters?: import('../../components/index.js').FilterGroup | undefined;
+        joinPlan?: import('../../components/index.js').JoinPlan | undefined;
+        relationshipHint?: {
+            relationshipIds?: string[] | undefined;
+        } | undefined;
+    }, {
+        kind: "matrix";
+        source: {
+            kind: "semantic";
+            domainId: string;
+            datasetName: string;
+            datasetId?: string | undefined;
+            label?: string | undefined;
+            connectionId?: string | undefined;
+        } | {
+            kind: "physical";
+            connectionId: string;
+            tableName: string;
+            label?: string | undefined;
+            connectionType?: string | undefined;
+            databaseName?: string | undefined;
+            schemaName?: string | undefined;
+            dialect?: "postgres" | "mysql" | "mssql" | "snowflake" | "clickhouse" | "bigquery" | "redshift" | "duckdb" | "sqlite" | "unknown" | undefined;
+        };
+        columns: readonly import('./matrix-definition-contract.js').MatrixLevel[];
+        measures: readonly ({
+            id: string;
+            kind: "aggregate";
+            aggregate: "SUM" | "COUNT" | "AVG" | "MIN" | "MAX" | "DISTINCT";
+            field: Omit<import('./contracts.js').SemaphorExecutionFieldRef, "source" | "aggregate" | "derivedField"> & {
+                source?: import('./contracts.js').SemaphorMatrixSourceRef;
+                derivedField?: Omit<import('./contracts.js').SemaphorDerivedFieldDefinition, "inputs"> & {
+                    inputs: Record<string, {
+                        kind: "field";
+                        field: Omit<import('./contracts.js').SemaphorFieldRef, "source"> & {
+                            source?: import('./contracts.js').SemaphorMatrixSourceRef;
+                        };
+                        aggregate?: import('./contracts.js').SemaphorAggregateFunction;
+                    }>;
+                };
+            };
+        } | {
+            id: string;
+            kind: "calculated";
+            definition: Omit<import('./contracts.js').SemaphorDerivedFieldDefinition, "inputs"> & {
+                inputs: Record<string, {
+                    kind: "field";
+                    field: Omit<import('./contracts.js').SemaphorFieldRef, "source"> & {
+                        source?: import('./contracts.js').SemaphorMatrixSourceRef;
+                    };
+                    aggregate?: import('./contracts.js').SemaphorAggregateFunction;
+                }>;
+            };
+        })[];
+        rows: readonly import('./matrix-definition-contract.js').MatrixLevel[];
+        sorts: readonly {
+            target: import('./matrix-definition-contract.js').MatrixSortTarget;
+            scope: {
+                kind: "level";
+            } | {
+                kind: "branch";
+                parent: readonly {
+                    member: {
+                        value: string | number | boolean | {
+                            value: string;
+                            type: "integer" | "decimal";
+                            kind: "exact_number";
+                        } | null;
+                        kind: "value";
+                    } | {
+                        kind: "others";
+                        rankingId: string;
+                    };
+                    levelId: string;
+                }[];
+            };
+            levelId: string;
+            axis: "columns" | "rows";
+            direction: "asc" | "desc";
+            nulls: "first" | "last";
+        }[];
+        rankings: readonly import('./matrix-definition-contract.js').MatrixRanking[];
+        filters?: import('../../components/index.js').FilterGroup | undefined;
+        joinPlan?: import('../../components/index.js').JoinPlan | undefined;
+        relationshipHint?: {
+            relationshipIds?: string[] | undefined;
+        } | undefined;
+    }>, {
+        kind: "matrix";
+        source: {
+            kind: "semantic";
+            domainId: string;
+            datasetName: string;
+            datasetId?: string | undefined;
+            label?: string | undefined;
+            connectionId?: string | undefined;
+        } | {
+            kind: "physical";
+            connectionId: string;
+            tableName: string;
+            label?: string | undefined;
+            connectionType?: string | undefined;
+            databaseName?: string | undefined;
+            schemaName?: string | undefined;
+            dialect?: "postgres" | "mysql" | "mssql" | "snowflake" | "clickhouse" | "bigquery" | "redshift" | "duckdb" | "sqlite" | "unknown" | undefined;
+        };
+        columns: readonly import('./matrix-definition-contract.js').MatrixLevel[];
+        measures: readonly ({
+            id: string;
+            kind: "aggregate";
+            aggregate: "SUM" | "COUNT" | "AVG" | "MIN" | "MAX" | "DISTINCT";
+            field: Omit<import('./contracts.js').SemaphorExecutionFieldRef, "source" | "aggregate" | "derivedField"> & {
+                source?: import('./contracts.js').SemaphorMatrixSourceRef;
+                derivedField?: Omit<import('./contracts.js').SemaphorDerivedFieldDefinition, "inputs"> & {
+                    inputs: Record<string, {
+                        kind: "field";
+                        field: Omit<import('./contracts.js').SemaphorFieldRef, "source"> & {
+                            source?: import('./contracts.js').SemaphorMatrixSourceRef;
+                        };
+                        aggregate?: import('./contracts.js').SemaphorAggregateFunction;
+                    }>;
+                };
+            };
+        } | {
+            id: string;
+            kind: "calculated";
+            definition: Omit<import('./contracts.js').SemaphorDerivedFieldDefinition, "inputs"> & {
+                inputs: Record<string, {
+                    kind: "field";
+                    field: Omit<import('./contracts.js').SemaphorFieldRef, "source"> & {
+                        source?: import('./contracts.js').SemaphorMatrixSourceRef;
+                    };
+                    aggregate?: import('./contracts.js').SemaphorAggregateFunction;
+                }>;
+            };
+        })[];
+        rows: readonly import('./matrix-definition-contract.js').MatrixLevel[];
+        sorts: readonly {
+            target: import('./matrix-definition-contract.js').MatrixSortTarget;
+            scope: {
+                kind: "level";
+            } | {
+                kind: "branch";
+                parent: readonly {
+                    member: {
+                        value: string | number | boolean | {
+                            value: string;
+                            type: "integer" | "decimal";
+                            kind: "exact_number";
+                        } | null;
+                        kind: "value";
+                    } | {
+                        kind: "others";
+                        rankingId: string;
+                    };
+                    levelId: string;
+                }[];
+            };
+            levelId: string;
+            axis: "columns" | "rows";
+            direction: "asc" | "desc";
+            nulls: "first" | "last";
+        }[];
+        rankings: readonly import('./matrix-definition-contract.js').MatrixRanking[];
+        filters?: import('../../components/index.js').FilterGroup | undefined;
+        joinPlan?: import('../../components/index.js').JoinPlan | undefined;
+        relationshipHint?: {
+            relationshipIds?: string[] | undefined;
+        } | undefined;
+    }, {
+        kind: "matrix";
+        source: {
+            kind: "semantic";
+            domainId: string;
+            datasetName: string;
+            datasetId?: string | undefined;
+            label?: string | undefined;
+            connectionId?: string | undefined;
+        } | {
+            kind: "physical";
+            connectionId: string;
+            tableName: string;
+            label?: string | undefined;
+            connectionType?: string | undefined;
+            databaseName?: string | undefined;
+            schemaName?: string | undefined;
+            dialect?: "postgres" | "mysql" | "mssql" | "snowflake" | "clickhouse" | "bigquery" | "redshift" | "duckdb" | "sqlite" | "unknown" | undefined;
+        };
+        columns: readonly import('./matrix-definition-contract.js').MatrixLevel[];
+        measures: readonly ({
+            id: string;
+            kind: "aggregate";
+            aggregate: "SUM" | "COUNT" | "AVG" | "MIN" | "MAX" | "DISTINCT";
+            field: Omit<import('./contracts.js').SemaphorExecutionFieldRef, "source" | "aggregate" | "derivedField"> & {
+                source?: import('./contracts.js').SemaphorMatrixSourceRef;
+                derivedField?: Omit<import('./contracts.js').SemaphorDerivedFieldDefinition, "inputs"> & {
+                    inputs: Record<string, {
+                        kind: "field";
+                        field: Omit<import('./contracts.js').SemaphorFieldRef, "source"> & {
+                            source?: import('./contracts.js').SemaphorMatrixSourceRef;
+                        };
+                        aggregate?: import('./contracts.js').SemaphorAggregateFunction;
+                    }>;
+                };
+            };
+        } | {
+            id: string;
+            kind: "calculated";
+            definition: Omit<import('./contracts.js').SemaphorDerivedFieldDefinition, "inputs"> & {
+                inputs: Record<string, {
+                    kind: "field";
+                    field: Omit<import('./contracts.js').SemaphorFieldRef, "source"> & {
+                        source?: import('./contracts.js').SemaphorMatrixSourceRef;
+                    };
+                    aggregate?: import('./contracts.js').SemaphorAggregateFunction;
+                }>;
+            };
+        })[];
+        rows: readonly import('./matrix-definition-contract.js').MatrixLevel[];
+        sorts: readonly {
+            target: import('./matrix-definition-contract.js').MatrixSortTarget;
+            scope: {
+                kind: "level";
+            } | {
+                kind: "branch";
+                parent: readonly {
+                    member: {
+                        value: string | number | boolean | {
+                            value: string;
+                            type: "integer" | "decimal";
+                            kind: "exact_number";
+                        } | null;
+                        kind: "value";
+                    } | {
+                        kind: "others";
+                        rankingId: string;
+                    };
+                    levelId: string;
+                }[];
+            };
+            levelId: string;
+            axis: "columns" | "rows";
+            direction: "asc" | "desc";
+            nulls: "first" | "last";
+        }[];
+        rankings: readonly import('./matrix-definition-contract.js').MatrixRanking[];
+        filters?: import('../../components/index.js').FilterGroup | undefined;
+        joinPlan?: import('../../components/index.js').JoinPlan | undefined;
+        relationshipHint?: {
+            relationshipIds?: string[] | undefined;
+        } | undefined;
+    }>;
+    resultShape: z.ZodLiteral<"matrix">;
+    result: z.ZodOptional<z.ZodType<{
+        kind: "matrix";
+        window: import('./matrix-window-contract.js').MatrixWindow;
+    }, z.ZodTypeDef, {
+        kind: "matrix";
+        window: import('./matrix-window-contract.js').MatrixWindow;
+    }>>;
+    metadata: z.ZodObject<{
+        rowLimitExceeded: z.ZodBoolean;
+        matrixFailure: z.ZodOptional<z.ZodType<import('./matrix-window-contract.js').MatrixFailure, z.ZodTypeDef, import('./matrix-window-contract.js').MatrixFailure>>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        rowLimitExceeded: z.ZodBoolean;
+        matrixFailure: z.ZodOptional<z.ZodType<import('./matrix-window-contract.js').MatrixFailure, z.ZodTypeDef, import('./matrix-window-contract.js').MatrixFailure>>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        rowLimitExceeded: z.ZodBoolean;
+        matrixFailure: z.ZodOptional<z.ZodType<import('./matrix-window-contract.js').MatrixFailure, z.ZodTypeDef, import('./matrix-window-contract.js').MatrixFailure>>;
+    }, z.ZodTypeAny, "passthrough">>;
+};
+type MatrixExecutionShape = Omit<typeof analyticsExecutionEnvelopeSchema.shape, keyof typeof matrixExecutionShape> & typeof matrixExecutionShape;
+declare const matrixExecutionEnvelope: z.ZodObject<MatrixExecutionShape>;
+export declare const matrixExecutionResultSchema: z.ZodEffects<typeof matrixExecutionEnvelope>;
+export type MatrixExecutionResult = z.infer<typeof matrixExecutionResultSchema>;