@cohesivesystems/relations 0.1.0-alpha.4 → 0.1.0-alpha.6

package/dist/generated/relations.shapes.generated.d.ts

@@ -1,27 +1,788 @@
-export interface GraphId {
-    Value: string;
+export type GraphId = string;
+export type ShapeId = string;
+export type RelationQueryExplainStage = {
+    readonly $stage: 'staticCompilation';
+} & RelationQueryStaticCompilationExplainStage | {
+    readonly $stage: 'profileFeasibility';
+} & RelationQueryProfileFeasibilityExplainStage | {
+    readonly $stage: 'sourcePlacement';
+} & RelationQuerySourcePlacementExplainStage | {
+    readonly $stage: 'boundRealization';
+} & RelationQueryBoundRealizationExplainStage | {
+    readonly $stage: 'physicalPlanning';
+} & RelationQueryPhysicalPlanningExplainStage | {
+    readonly $stage: 'nativeCompilation';
+} & RelationQueryNativeCompilationExplainStage | {
+    readonly $stage: 'evaluation';
+} & RelationQueryEvaluationExplainStage;
+export interface RelationQueryStaticCompilationExplainStage {
+    status: RelationQueryExplainStageStatus;
+    request: RelationQueryCompilationRequestReference;
+    plan?: RelationQueryStaticPlanExplanation | null;
+    diagnostics: DocumentValidationDiagnostic[];
 }
-export interface ShapeId {
-    Value: string;
+export interface RelationQueryProfileFeasibilityExplainStage {
+    status: RelationQueryExplainStageStatus;
+    report: RelationQueryRealizationReport;
 }
-export interface RelationId {
-    Value: string;
+export interface RelationQuerySourcePlacementExplainStage {
+    status: RelationQueryExplainStageStatus;
+    placement: RelationQuerySourcePlacement;
 }
-export interface RelationName {
-    Value: string;
+export interface RelationQueryBoundRealizationExplainStage {
+    report: RelationQueryBoundRealizationReport;
+    status: RelationQueryExplainStageStatus;
 }
-export interface RelationSource {
-    Alias: SourceAlias;
-    ShapeId: ShapeId;
-    Cardinality: SourceCardinality;
+export interface RelationQueryPhysicalPlanningExplainStage {
+    status: RelationQueryExplainStageStatus;
+    plan: RelationQueryCompiledPlanReference;
+    realization: RelationQueryRealizationFingerprint;
+    placement: RelationQuerySourcePlacementFingerprint;
+    policy?: RelationQueryPhysicalPlanningPolicy | null;
+    result: RelationQueryPhysicalPlanningResult;
 }
-export interface JoinDefinition {
-    Left: SourceAlias;
-    Right: SourceAlias;
-    Kind: JoinKind;
-    On: Expr;
+export interface RelationQueryNativeCompilationExplainStage {
+    status: RelationQueryExplainStageStatus;
+    attempt: RelationQueryNativeCompilationAttemptReference;
+    compilation: RelationQueryNativeCompilationExplanation;
 }
+export interface RelationQueryEvaluationExplainStage {
+    evaluation: RelationQueryEvaluationExplanation;
+    status: RelationQueryExplainStageStatus;
+}
+export interface RelationQueryCapabilitySummary {
+    target: RelationQueryTargetId;
+    targetProfile: RelationQueryTargetProfileId;
+    policy?: RelationQueryRealizationPolicyId | null;
+    profileFeasibility?: RelationQueryRealizationFingerprint | null;
+    boundRealization?: RelationQueryBoundRealizationFingerprint | null;
+    operatingBoundaries: RelationQueryOperatingBoundaryId[];
+    entries: RelationQueryCapabilitySummaryEntry[];
+}
+export interface RelationQueryExplainDiagnostic {
+    stage: string;
+    code: string;
+    severity: DiagnosticSeverity;
+    message: string;
+    location?: string | null;
+    branch?: RelationQueryNativeResultBranchId | null;
+    requirement?: RelationQueryRealizationRequirementId | null;
+    node?: QueryNodeId | null;
+    input?: RelationQueryInputId | null;
+    output?: RelationQueryOutputId | null;
+    placementBinding?: RelationQuerySourcePlacementBindingId | null;
+    physicalStage?: RelationQueryPhysicalStageId | null;
+    source?: RelationQuerySourceInstanceId | null;
+    capabilityEvidence?: RelationQueryTargetCapabilityEvidenceId | null;
+    operatingBoundary?: RelationQueryOperatingBoundaryId | null;
+    contextEvidence?: RelationQueryContextEvidenceId | null;
+    semanticSite?: string | null;
+    compositionRule?: RelationQueryCompositionRuleId | null;
+    override?: RelationQueryRealizationOverrideId | null;
+    field?: FieldPath | null;
+    bindingSetting?: string | null;
+    resolution?: string | null;
+    configurationOrigin?: EffectiveConfigurationOrigin | null;
+    configurationAuthority?: string | null;
+    adapterDecisionCode?: RelationQueryAdapterDecisionCode | null;
+}
+export interface RelationQueryExplainFingerprint {
+    algorithm: string;
+    canonicalization: string;
+    value: string;
+}
+export interface RelationQueryCompiledPlanReference {
+    compilerProfile: string;
+    definitionSchemaVersion: string;
+    definitionFingerprint: RelationQueryDefinitionFingerprint;
+    shapeSnapshotsFingerprint: RelationQueryPlanComponentFingerprint;
+    relationshipCatalogFingerprint?: RelationshipCatalogFingerprint | null;
+    demandFingerprint: RelationQueryPlanComponentFingerprint;
+    inputs: RelationQueryInputId[];
+}
+export interface RelationQueryRealizationFingerprint {
+    algorithm: string;
+    canonicalization: string;
+    value: string;
+}
+export interface RelationQueryPhysicalPlanningPolicy {
+    id: RelationQueryPhysicalPlanningPolicyId;
+    conventionSetVersion: string;
+    maximumBatchSize: string;
+    maximumBufferedRows: string;
+    maximumLocalRows: string;
+    maximumFanOut: string;
+    maximumReferenceKeysPerObservation: string;
+    maximumConcurrency: string;
+    loweringSelections: RelationQueryPhysicalLoweringSelection[];
+}
+export interface RelationQueryPhysicalStage {
+    id: RelationQueryPhysicalStageId;
+    kind: RelationQueryPhysicalStageKind;
+    dependencies: RelationQueryPhysicalStageId[];
+    placementBinding?: RelationQuerySourcePlacementBindingId | null;
+    semanticInputs: RelationQueryInputId[];
+    requestedFields: RelationQueryInputId[];
+    batchSize?: string | null;
+    provenance: RelationQueryPhysicalStageProvenance;
+}
+export type RelationQueryPhysicalStageId = string;
+export interface RelationQueryPhysicalPlanningDiagnostic {
+    code: string;
+    severity: DiagnosticSeverity;
+    message: string;
+    input?: RelationQueryInputId | null;
+    stage?: RelationQueryPhysicalStageId | null;
+    placementBinding?: RelationQuerySourcePlacementBindingId | null;
+    requirement?: RelationQueryRealizationRequirementId | null;
+}
+export interface RelationQueryPhysicalPlanFingerprint {
+    algorithm: string;
+    canonicalization: string;
+    value: string;
+}
+export interface RelationQuerySourceInstance {
+    id: RelationQuerySourceInstanceId;
+    executionDomain: RelationQueryExecutionDomainId;
+    targetProfile: RelationQueryTargetCapabilityProfile;
+    limits: RelationQuerySourcePlacementLimits;
+}
+export interface RelationQuerySourcePlacementBinding {
+    id: RelationQuerySourcePlacementBindingId;
+    input: RelationQueryInputId;
+    node: QueryNodeId;
+    binding: ValueBindingId;
+    shape: QualifiedShapeId;
+    source: RelationQuerySourceInstanceId;
+    kind: RelationQuerySourcePlacementBindingKind;
+    acquisition: RelationQuerySourceAcquisitionKind;
+    origin: RelationQuerySourcePlacementOrigin;
+    identity?: RelationQuerySourceIdentityBinding | null;
+    fields: RelationQuerySourceFieldBinding[];
+    relationshipKeys: RelationQueryRelationshipKeyBinding[];
+    partition?: RelationQueryPartitionBinding | null;
+}
+export interface EffectiveConfigurationDecision {
+    setting: string;
+    origin: EffectiveConfigurationOrigin;
+    authority: string;
+}
+export interface RelationQuerySourcePlacementFingerprint {
+    algorithm: string;
+    canonicalization: string;
+    value: string;
+}
+export type RelationQueryNativeResultBranchId = string;
+export interface RelationQueryContextualEvidenceProjection {
+    binding: RelationQueryAdapterBindingReference;
+    assessments: RelationQueryBoundRequirementAssessment[];
+}
+export interface RelationQueryRealizationDiagnostic {
+    code: string;
+    severity: DiagnosticSeverity;
+    message: string;
+    requirement?: RelationQueryRealizationRequirementId | null;
+    capabilityEvidence?: RelationQueryTargetCapabilityEvidenceId | null;
+    compositionRule?: RelationQueryCompositionRuleId | null;
+    operatingBoundary?: RelationQueryOperatingBoundaryId | null;
+    override?: RelationQueryRealizationOverrideId | null;
+    node?: QueryNodeId | null;
+    semanticSite?: string | null;
+    contextEvidence?: RelationQueryContextEvidenceId | null;
+    branch?: RelationQueryNativeResultBranchId | null;
+    input?: RelationQueryInputId | null;
+    field?: FieldPath | null;
+    placementBinding?: RelationQuerySourcePlacementBindingId | null;
+    bindingSetting?: string | null;
+    resolution?: string | null;
+    configurationOrigin?: EffectiveConfigurationOrigin | null;
+    configurationAuthority?: string | null;
+    adapterDecisionCode?: RelationQueryAdapterDecisionCode | null;
+}
+export type RelationQueryRealizationStatus = 'Realizable' | 'NotRealizable' | 'Invalid';
+export declare const relationQueryRealizationStatuses: {
+    readonly realizable: "Realizable";
+    readonly notRealizable: "NotRealizable";
+    readonly invalid: "Invalid";
+};
+export declare const relationQueryRealizationStatusLabels: Record<RelationQueryRealizationStatus, string>;
+export interface RelationQueryBoundRealizationFingerprint {
+    algorithm: string;
+    canonicalization: string;
+    value: string;
+}
+export interface RelationQueryRealizationPolicy {
+    id: RelationQueryRealizationPolicyId;
+    conventionSetVersion: string;
+    preference: RelationQueryRealizationPreference;
+    constrainedRealizations: RelationQueryConstrainedRealizationPolicy;
+    compositionRules: RelationQueryCompositionRule[];
+    compositionRuleSelections: RelationQueryCompositionRuleSelection[];
+    overrides: RelationQueryRealizationOverride[];
+    diagnosticSeverityOverrides: RelationQueryRealizationDiagnosticSeverityOverride[];
+}
+export interface RelationQueryResultObservability {
+    occurrenceProvenance: RelationQueryOccurrenceProvenanceMode;
+}
+export interface RelationQueryRealizationRequirement {
+    id: RelationQueryRealizationRequirementId;
+    capability: RelationQueryCapability;
+    origin?: RelationQueryRealizationRequirementOrigin | null;
+    uses: RelationQueryRealizationRequirementUse[];
+    requiredGuarantees: RelationQueryGuaranteeCapabilityKind[];
+    staticFacts: RelationQueryRealizationStaticFact[];
+}
+export type RelationQueryRealizationDecision = {
+    readonly $decision: 'native';
+} & NativeRelationQueryRealizationDecision | {
+    readonly $decision: 'composed';
+} & ComposedRelationQueryRealizationDecision | {
+    readonly $decision: 'constrained';
+} & ConstrainedRelationQueryRealizationDecision | {
+    readonly $decision: 'override';
+} & OverrideRelationQueryRealizationDecision | {
+    readonly $decision: 'unavailable';
+} & UnavailableRelationQueryRealizationDecision;
+export interface NativeRelationQueryRealizationDecision {
+    capabilityEvidence: RelationQueryTargetCapabilityEvidenceId[];
+    preservedGuarantees: RelationQueryGuaranteeCapabilityKind[];
+    requirement: RelationQueryRealizationRequirementId;
+}
+export interface ComposedRelationQueryRealizationDecision {
+    compositionRules: RelationQueryCompositionRuleId[];
+    capabilityEvidence: RelationQueryTargetCapabilityEvidenceId[];
+    preservedGuarantees: RelationQueryGuaranteeCapabilityKind[];
+    requirement: RelationQueryRealizationRequirementId;
+}
+export interface ConstrainedRelationQueryRealizationDecision {
+    capabilityEvidence: RelationQueryTargetCapabilityEvidenceId[];
+    boundaryValidations: RelationQueryOperatingBoundaryValidation[];
+    compositionRules: RelationQueryCompositionRuleId[];
+    preservedGuarantees: RelationQueryGuaranteeCapabilityKind[];
+    requirement: RelationQueryRealizationRequirementId;
+}
+export interface OverrideRelationQueryRealizationDecision {
+    override: RelationQueryRealizationOverrideId;
+    capabilityEvidence: RelationQueryTargetCapabilityEvidenceId[];
+    boundaryValidations: RelationQueryOperatingBoundaryValidation[];
+    preservedGuarantees: RelationQueryGuaranteeCapabilityKind[];
+    requirement: RelationQueryRealizationRequirementId;
+}
+export interface UnavailableRelationQueryRealizationDecision {
+    requirement: RelationQueryRealizationRequirementId;
+    reason: RelationQueryUnavailableReason;
+    missingCapabilities: RelationQueryCapability[];
+}
+export type RelationQueryTargetId = string;
+export type RelationQueryTargetProfileId = string;
+export interface RelationQueryTargetCapabilityEvidence {
+    id: RelationQueryTargetCapabilityEvidenceId;
+    capability: RelationQueryCapability;
+    operatingBoundaries: RelationQueryOperatingBoundaryId[];
+    description?: string | null;
+}
+export interface RelationQueryOperatingBoundary {
+    id: RelationQueryOperatingBoundaryId;
+    kind: RelationQueryOperatingBoundaryKind | number;
+    limit?: string | null;
+    description?: string | null;
+}
+export interface RelationDraft {
+    id: RelationDraftId;
+    relationId: RelationId;
+    name: RelationName;
+    input: LogicalQueryDefinition;
+    rootBinding: ValueBindingId;
+    projection: RelationDraftProjection;
+    outputMode: RelationOutputMode;
+    outputKey?: Expr | null;
+    invariants: InvariantDefinition[];
+}
+export interface RelationDraftFingerprint {
+    algorithm: string;
+    canonicalization: string;
+    value: string;
+}
+export interface RelationDraftDocumentMetadata {
+    origin: DocumentOrigin;
+    name?: string | null;
+    description?: string | null;
+    sourceUri?: string | null;
+    producer?: string | null;
+    producerVersion?: string | null;
+    createdAtUtc?: string | null;
+    updatedAtUtc?: string | null;
+    annotations: Record<string, AnnotationValue>;
+    producerArtifacts: RelationDraftProducerArtifactReference[];
+    conventionDecisions: RelationDraftConventionDecision[];
+}
+export type RelationQueryDefinition = {
+    readonly $definition: 'relation';
+} & RelationDefinition | {
+    readonly $definition: 'query';
+} & QueryDefinition;
+export interface RelationDefinition {
+    id: RelationId;
+    name: RelationName;
+    rootBinding: ValueBindingId;
+    output: RelationOutputDefinition;
+    invariants: InvariantDefinition[];
+    body: LogicalQueryDefinition;
+}
+export interface QueryDefinition {
+    id: QueryId;
+    name: QueryName;
+    results: QueryResultDefinition[];
+    body: LogicalQueryDefinition;
+}
+export interface RelationQueryDefinitionFingerprint {
+    algorithm: string;
+    canonicalization: string;
+    value: string;
+}
+export interface RelationQueryDocumentMetadata {
+    origin: DocumentOrigin;
+    name?: string | null;
+    description?: string | null;
+    sourceUri?: string | null;
+    producer?: string | null;
+    producerVersion?: string | null;
+    createdAtUtc?: string | null;
+    updatedAtUtc?: string | null;
+    annotations: Record<string, AnnotationValue>;
+}
+export interface RelationshipCatalog {
+    relationships: RelationshipDefinition[];
+}
+export interface RelationshipCatalogFingerprint {
+    algorithm: string;
+    canonicalization: string;
+    value: string;
+}
+export interface RelationshipCatalogDocumentMetadata {
+    origin: DocumentOrigin;
+    name?: string | null;
+    description?: string | null;
+    sourceUri?: string | null;
+    producer?: string | null;
+    producerVersion?: string | null;
+    createdAtUtc?: string | null;
+    updatedAtUtc?: string | null;
+    annotations: Record<string, AnnotationValue>;
+}
+export type RelationQueryExplainStageStatus = 'Complete' | 'Unavailable' | 'Invalid' | 'Incomplete' | 'Failed';
+export declare const relationQueryExplainStageStatuses: {
+    readonly complete: "Complete";
+    readonly unavailable: "Unavailable";
+    readonly invalid: "Invalid";
+    readonly incomplete: "Incomplete";
+    readonly failed: "Failed";
+};
+export declare const relationQueryExplainStageStatusLabels: Record<RelationQueryExplainStageStatus, string>;
+export interface RelationQueryCompilationRequestReference {
+    compilerProfile: string;
+    definitionSchemaVersion: string;
+    definitionFingerprint: RelationQueryDefinitionFingerprint;
+    shapeSnapshotsFingerprint: RelationQueryPlanComponentFingerprint;
+    relationshipCatalogFingerprint?: RelationshipCatalogFingerprint | null;
+    demandFingerprint: RelationQueryPlanComponentFingerprint;
+}
+export interface RelationQueryStaticPlanExplanation {
+    reference: RelationQueryCompiledPlanReference;
+    logicalPlan: RelationQueryLogicalPlan;
+    requirementGraph: RelationQueryExplainRequirementGraph;
+    branches: RelationQueryNativeResultBranch[];
+    observability: RelationQueryResultObservability;
+    realizationRequirements: RelationQueryRealizationRequirement[];
+    realizationRequirementsFingerprint: RelationQueryPlanComponentFingerprint;
+}
+export interface DocumentValidationDiagnostic {
+    code: string;
+    severity: DiagnosticSeverity;
+    message: string;
+    location?: string | null;
+    schemaLocation?: string | null;
+    evidence?: DocumentDiagnosticEvidence | null;
+}
+export interface RelationQueryPhysicalPlanningResult {
+    status: RelationQueryPhysicalPlanningStatus;
+    plan?: CompiledRelationQueryPhysicalPlan | null;
+    diagnostics: RelationQueryPhysicalPlanningDiagnostic[];
+}
+export interface RelationQueryNativeCompilationAttemptReference {
+    plan: RelationQueryCompiledPlanReference;
+    profileFeasibility: RelationQueryRealizationFingerprint;
+    boundRealization: RelationQueryBoundRealizationFingerprint;
+    placement: RelationQuerySourcePlacementFingerprint;
+    adapterBinding: RelationQueryAdapterBindingReference;
+    branches: RelationQueryNativeResultBranchId[];
+}
+export interface RelationQueryNativeCompilationExplanation {
+    status: RelationQueryNativeCompilationStatus;
+    artifacts: RelationQueryNativeArtifactReference[];
+    diagnostics: RelationQueryNativeCompilationDiagnostic[];
+}
+export interface RelationQueryEvaluationExplanation {
+    evaluation: RelationQueryEvaluationFingerprint;
+    plan?: RelationQueryCompiledPlanReference | null;
+    status: RelationQueryExecutionStatus;
+    results: RelationQueryExplainResultSummary[];
+    requirementGaps: RelationQueryExplainRequirementGapSummary[];
+    diagnostics: RelationQueryExplainDiagnostic[];
+    observationFingerprint: RelationQueryEvaluationObservationFingerprint;
+}
+export type RelationQueryRealizationPolicyId = string;
+export type RelationQueryOperatingBoundaryId = string;
+export interface RelationQueryCapabilitySummaryEntry {
+    capability: RelationQueryCapability;
+    requirements: RelationQueryRealizationRequirementId[];
+    missingForRequirements: RelationQueryRealizationRequirementId[];
+    capabilityEvidence: RelationQueryTargetCapabilityEvidenceId[];
+    operatingBoundaries: RelationQueryOperatingBoundaryId[];
+    contextEvidence: RelationQueryContextEvidenceId[];
+}
+export type DiagnosticSeverity = 'Info' | 'Warning' | 'Error';
+export declare const diagnosticSeverities: {
+    readonly info: "Info";
+    readonly warning: "Warning";
+    readonly error: "Error";
+};
+export declare const diagnosticSeverityLabels: Record<DiagnosticSeverity, string>;
+export type RelationQueryRealizationRequirementId = string;
+export type QueryNodeId = string;
+export type RelationQueryInputId = string;
+export type RelationQueryOutputId = string;
+export type RelationQuerySourcePlacementBindingId = string;
+export type RelationQuerySourceInstanceId = string;
+export type RelationQueryTargetCapabilityEvidenceId = string;
+export type RelationQueryContextEvidenceId = string;
+export type RelationQueryCompositionRuleId = string;
+export type RelationQueryRealizationOverrideId = string;
+export interface FieldPath {
+    segments: FieldPathSegment[];
+}
+export type EffectiveConfigurationOrigin = 'Explicit' | 'ScopedProfile' | 'AdapterConvention' | 'FrameworkDefault';
+export declare const effectiveConfigurationOrigins: {
+    readonly explicit: "Explicit";
+    readonly scopedProfile: "ScopedProfile";
+    readonly adapterConvention: "AdapterConvention";
+    readonly frameworkDefault: "FrameworkDefault";
+};
+export declare const effectiveConfigurationOriginLabels: Record<EffectiveConfigurationOrigin, string>;
+export type RelationQueryAdapterDecisionCode = string;
+export interface RelationQueryPlanComponentFingerprint {
+    algorithm: string;
+    canonicalization: string;
+    value: string;
+}
+export type RelationQueryPhysicalPlanningPolicyId = string;
+export interface RelationQueryPhysicalLoweringSelection {
+    compositionRule: RelationQueryCompositionRuleId;
+    physicalLowering: RelationQueryPhysicalLoweringRuleId;
+}
+export type RelationQueryPhysicalStageKind = 'SuppliedInput' | 'SourceRead' | 'ExactFieldProjection' | 'RelationshipKeyExtraction' | 'KeyDeduplication' | 'BatchedIdentityLookup' | 'BatchedPredicateLookup' | 'LocalCorrelation' | 'RuntimeEvidenceAssembly' | 'ReferenceInterpreterTerminal';
+export declare const relationQueryPhysicalStageKinds: {
+    readonly suppliedInput: "SuppliedInput";
+    readonly sourceRead: "SourceRead";
+    readonly exactFieldProjection: "ExactFieldProjection";
+    readonly relationshipKeyExtraction: "RelationshipKeyExtraction";
+    readonly keyDeduplication: "KeyDeduplication";
+    readonly batchedIdentityLookup: "BatchedIdentityLookup";
+    readonly batchedPredicateLookup: "BatchedPredicateLookup";
+    readonly localCorrelation: "LocalCorrelation";
+    readonly runtimeEvidenceAssembly: "RuntimeEvidenceAssembly";
+    readonly referenceInterpreterTerminal: "ReferenceInterpreterTerminal";
+};
+export declare const relationQueryPhysicalStageKindLabels: Record<RelationQueryPhysicalStageKind, string>;
+export interface RelationQueryPhysicalStageProvenance {
+    nodes: QueryNodeId[];
+    inputs: RelationQueryInputId[];
+    requirements: RelationQueryRealizationRequirementId[];
+    capabilityEvidence: RelationQueryPhysicalCapabilityEvidenceReference[];
+    compositionRules: RelationQueryCompositionRuleId[];
+    operatingBoundaries: RelationQueryOperatingBoundaryId[];
+    placementBindings: RelationQuerySourcePlacementBindingId[];
+    loweringRule?: RelationQueryPhysicalLoweringRuleId | null;
+    policyDecisions: RelationQueryPhysicalPlanningDecisionId[];
+}
+export type RelationQueryExecutionDomainId = string;
+export interface RelationQuerySourcePlacementLimits {
+    maximumBatchSize: string;
+    maximumBufferedRows: string;
+    maximumFanOut: string;
+    maximumConcurrency: string;
+}
+export type ValueBindingId = string;
+export type RelationQuerySourcePlacementBindingKind = 'SourceSet' | 'RelationshipTraversal';
+export declare const relationQuerySourcePlacementBindingKinds: {
+    readonly sourceSet: "SourceSet";
+    readonly relationshipTraversal: "RelationshipTraversal";
+};
+export declare const relationQuerySourcePlacementBindingKindLabels: Record<RelationQuerySourcePlacementBindingKind, string>;
+export type RelationQuerySourceAcquisitionKind = 'Supplied' | 'BoundedEnumeration' | 'BoundedLookup';
+export declare const relationQuerySourceAcquisitionKinds: {
+    readonly supplied: "Supplied";
+    readonly boundedEnumeration: "BoundedEnumeration";
+    readonly boundedLookup: "BoundedLookup";
+};
+export declare const relationQuerySourceAcquisitionKindLabels: Record<RelationQuerySourceAcquisitionKind, string>;
+export type RelationQuerySourcePlacementOrigin = 'Explicit' | 'Convention';
+export declare const relationQuerySourcePlacementOrigins: {
+    readonly explicit: "Explicit";
+    readonly convention: "Convention";
+};
+export declare const relationQuerySourcePlacementOriginLabels: Record<RelationQuerySourcePlacementOrigin, string>;
+export interface RelationQuerySourceIdentityBinding {
+    shape: QualifiedShapeId;
+    sourceSelector: string;
+    semanticPath?: FieldPath | null;
+}
+export interface RelationQuerySourceFieldBinding {
+    input: RelationQueryInputId;
+    semanticPath: FieldPath;
+    sourceSelector: string;
+}
+export interface RelationQueryRelationshipKeyBinding {
+    input: RelationQueryInputId;
+    semanticPath: FieldPath;
+    sourceSelector: string;
+}
+export interface RelationQueryPartitionBinding {
+    sourceSelector: string;
+}
+export interface RelationQueryAdapterBindingReference {
+    schemaVersion: string;
+    bindingId: string;
+    target: RelationQueryTargetId;
+    targetProfile: RelationQueryTargetProfileId;
+    fingerprint: RelationQueryAdapterBindingFingerprint;
+    compiledPlanFingerprint?: RelationQueryPlanComponentFingerprint | null;
+    placementFingerprint?: RelationQuerySourcePlacementFingerprint | null;
+    sources: RelationQuerySourceInstanceId[];
+    placementBindings: RelationQuerySourcePlacementBindingId[];
+    configurationDecisions: EffectiveConfigurationDecision[];
+}
+export interface RelationQueryBoundRequirementAssessment {
+    id: RelationQueryContextEvidenceId;
+    branch: RelationQueryNativeResultBranchId;
+    requirement: RelationQueryRealizationRequirementId;
+    status: RelationQueryBoundAssessmentStatus;
+    origin: EffectiveConfigurationOrigin;
+    authority: string;
+    capabilityEvidence: RelationQueryTargetCapabilityEvidenceId[];
+    operatingBoundaries: RelationQueryOperatingBoundaryId[];
+    preservedGuarantees: RelationQueryGuaranteeCapabilityKind[];
+    unavailableReason?: RelationQueryUnavailableReason | null;
+    node?: QueryNodeId | null;
+    input?: RelationQueryInputId | null;
+    field?: FieldPath | null;
+    placementBinding?: RelationQuerySourcePlacementBindingId | null;
+    configurationSetting?: string | null;
+    message: string;
+    resolution?: string | null;
+    adapterDecisionCode?: RelationQueryAdapterDecisionCode | null;
+    missingCapabilityEvidence: RelationQueryTargetCapabilityEvidenceId[];
+    failedOperatingBoundary?: RelationQueryOperatingBoundaryId | null;
+    failedConfigurationSetting?: string | null;
+    blockedBy?: RelationQueryContextEvidenceId | null;
+}
+export type RelationQueryRealizationPreference = 'PreferNative' | 'PreferComposed';
+export declare const relationQueryRealizationPreferences: {
+    readonly preferNative: "PreferNative";
+    readonly preferComposed: "PreferComposed";
+};
+export declare const relationQueryRealizationPreferenceLabels: Record<RelationQueryRealizationPreference, string>;
+export type RelationQueryConstrainedRealizationPolicy = 'Reject' | 'AllowValidated';
+export declare const relationQueryConstrainedRealizationPolicies: {
+    readonly reject: "Reject";
+    readonly allowValidated: "AllowValidated";
+};
+export declare const relationQueryConstrainedRealizationPolicyLabels: Record<RelationQueryConstrainedRealizationPolicy, string>;
+export interface RelationQueryCompositionRule {
+    id: RelationQueryCompositionRuleId;
+    providedCapability: RelationQueryCapability;
+    requiredCapabilities: RelationQueryCapability[];
+    requiredOperatingBoundaries: RelationQueryOperatingBoundaryId[];
+    preservedGuarantees: RelationQueryGuaranteeCapabilityKind[];
+    description?: string | null;
+}
+export interface RelationQueryCompositionRuleSelection {
+    capability: RelationQueryCapability;
+    rule: RelationQueryCompositionRuleId;
+}
+export interface RelationQueryRealizationOverride {
+    id: RelationQueryRealizationOverrideId;
+    requirement: RelationQueryRealizationRequirementId;
+    expectedCapability: RelationQueryCapability;
+    capabilityEvidence: RelationQueryTargetCapabilityEvidenceId[];
+    operatingBoundaries: RelationQueryOperatingBoundaryId[];
+    preservedGuarantees: RelationQueryGuaranteeCapabilityKind[];
+    justification: string;
+}
+export interface RelationQueryRealizationDiagnosticSeverityOverride {
+    code: string;
+    severity: DiagnosticSeverity;
+}
+export type RelationQueryOccurrenceProvenanceMode = 'ExactContributors' | 'NotRequested';
+export declare const relationQueryOccurrenceProvenanceModes: {
+    readonly exactContributors: "ExactContributors";
+    readonly notRequested: "NotRequested";
+};
+export declare const relationQueryOccurrenceProvenanceModeLabels: Record<RelationQueryOccurrenceProvenanceMode, string>;
+export type RelationQueryCapability = {
+    readonly $capability: 'logical';
+} & LogicalRelationQueryCapability | {
+    readonly $capability: 'expression';
+} & ExpressionRelationQueryCapability | {
+    readonly $capability: 'temporal';
+} & TemporalRelationQueryCapability | {
+    readonly $capability: 'structural';
+} & StructuralRelationQueryCapability | {
+    readonly $capability: 'guarantee';
+} & GuaranteeRelationQueryCapability | {
+    readonly $capability: 'operatingBoundaryValidation';
+} & OperatingBoundaryValidationRelationQueryCapability | {
+    readonly $capability: 'primitive';
+} & PrimitiveRelationQueryCapability;
+export interface LogicalRelationQueryCapability {
+    kind: RelationQueryLogicalCapabilityKind | number;
+}
+export interface ExpressionRelationQueryCapability {
+    capability: ExprCapabilityId;
+    requirementKind: ExprCapabilityRequirementKind | number;
+}
+export interface TemporalRelationQueryCapability {
+    capability: RelationQueryTemporalExecutionCapability | number;
+}
+export interface StructuralRelationQueryCapability {
+    role: RelationQueryStructuralCapabilityRole | number;
+    pathKind: RelationQueryStructuralPathKind | number;
+}
+export interface GuaranteeRelationQueryCapability {
+    kind: RelationQueryGuaranteeCapabilityKind | number;
+}
+export interface OperatingBoundaryValidationRelationQueryCapability {
+    boundary: RelationQueryOperatingBoundaryId;
+}
+export interface PrimitiveRelationQueryCapability {
+    kind: RelationQueryPrimitiveCapabilityKind | number;
+}
+export interface RelationQueryRealizationRequirementOrigin {
+    input?: RelationQueryInputId | null;
+    node?: QueryNodeId | null;
+    semanticSite?: string | null;
+    expressionPath?: string | null;
+    fieldPath?: FieldPath | null;
+    binding?: ValueBindingId | null;
+}
+export interface RelationQueryRealizationRequirementUse {
+    output: RelationQueryRealizationOutputReference;
+    effect: RelationQueryRequirementEffect;
+    requirement: QueryInputRequirement;
+    traces: RelationQueryRealizationTrace[];
+}
+export type RelationQueryGuaranteeCapabilityKind = 'MissingNullDistinction' | 'AbsenceAvailabilityFailureDistinction' | 'JoinMembership' | 'Cardinality' | 'RelationshipDirection' | 'RelationshipMultiplicity' | 'TemporalDomain' | 'TemporalBoundary' | 'UnboundedTemporalBoundary' | 'Ordering' | 'NullPlacement' | 'StablePaging' | 'Grouping' | 'Aggregation' | 'DuplicateHandling' | 'OutputIdentity' | 'OutputMode' | 'InvariantEnforcement' | 'DeterministicResult' | 'OccurrenceProvenance' | 'EvidenceCompleteness' | 'InconclusiveEvidence' | 'ConsistentSnapshot' | 'CollectionElementCorrelation' | 'RelationRootCorrelation';
+export declare const relationQueryGuaranteeCapabilityKinds: {
+    readonly missingNullDistinction: "MissingNullDistinction";
+    readonly absenceAvailabilityFailureDistinction: "AbsenceAvailabilityFailureDistinction";
+    readonly joinMembership: "JoinMembership";
+    readonly cardinality: "Cardinality";
+    readonly relationshipDirection: "RelationshipDirection";
+    readonly relationshipMultiplicity: "RelationshipMultiplicity";
+    readonly temporalDomain: "TemporalDomain";
+    readonly temporalBoundary: "TemporalBoundary";
+    readonly unboundedTemporalBoundary: "UnboundedTemporalBoundary";
+    readonly ordering: "Ordering";
+    readonly nullPlacement: "NullPlacement";
+    readonly stablePaging: "StablePaging";
+    readonly grouping: "Grouping";
+    readonly aggregation: "Aggregation";
+    readonly duplicateHandling: "DuplicateHandling";
+    readonly outputIdentity: "OutputIdentity";
+    readonly outputMode: "OutputMode";
+    readonly invariantEnforcement: "InvariantEnforcement";
+    readonly deterministicResult: "DeterministicResult";
+    readonly occurrenceProvenance: "OccurrenceProvenance";
+    readonly evidenceCompleteness: "EvidenceCompleteness";
+    readonly inconclusiveEvidence: "InconclusiveEvidence";
+    readonly consistentSnapshot: "ConsistentSnapshot";
+    readonly collectionElementCorrelation: "CollectionElementCorrelation";
+    readonly relationRootCorrelation: "RelationRootCorrelation";
+};
+export declare const relationQueryGuaranteeCapabilityKindLabels: Record<RelationQueryGuaranteeCapabilityKind, string>;
+export interface RelationQueryRealizationStaticFact {
+    kind: RelationQueryRealizationStaticFactKind;
+    value: string;
+}
+export interface RelationQueryOperatingBoundaryValidation {
+    boundary: RelationQueryOperatingBoundaryId;
+    kind: RelationQueryOperatingBoundaryValidationKind;
+    capabilityEvidence?: RelationQueryTargetCapabilityEvidenceId | null;
+    measuredValue?: string | null;
+}
+export type RelationQueryUnavailableReason = 'CapabilityNotAdvertised' | 'ProfileVersionUnsupported' | 'OperatingBoundaryMissing' | 'OperatingBoundaryInvalid' | 'CompositionUnavailable' | 'AmbiguousStrategy' | 'CapabilityEvidenceInvalid' | 'OverrideInvalid' | 'PolicyRejected' | 'PrerequisiteBlocked';
+export declare const relationQueryUnavailableReasons: {
+    readonly capabilityNotAdvertised: "CapabilityNotAdvertised";
+    readonly profileVersionUnsupported: "ProfileVersionUnsupported";
+    readonly operatingBoundaryMissing: "OperatingBoundaryMissing";
+    readonly operatingBoundaryInvalid: "OperatingBoundaryInvalid";
+    readonly compositionUnavailable: "CompositionUnavailable";
+    readonly ambiguousStrategy: "AmbiguousStrategy";
+    readonly capabilityEvidenceInvalid: "CapabilityEvidenceInvalid";
+    readonly overrideInvalid: "OverrideInvalid";
+    readonly policyRejected: "PolicyRejected";
+    readonly prerequisiteBlocked: "PrerequisiteBlocked";
+};
+export declare const relationQueryUnavailableReasonLabels: Record<RelationQueryUnavailableReason, string>;
+export type RelationQueryOperatingBoundaryKind = 'MaximumInputRows' | 'MaximumOutputRows' | 'MaximumFanOut' | 'MaximumPageSize' | 'MaximumFieldPathDepth' | 'MaximumExpressionDepth' | 'MaximumBatchSize' | 'SingleSource' | 'SinglePartition' | 'MaterializedInputs' | 'CompleteInputEvidence' | 'NonNullOperands' | 'ScalarOperands' | 'HomogeneousTemporalDomain' | 'FiniteTemporalBounds' | 'StableUniqueOrdering' | 'DeterministicProvider' | 'ExactNumericAggregateDomain' | 'ExactTemporalDomain' | 'SuppliedRelationRoot';
+export declare const relationQueryOperatingBoundaryKinds: {
+    readonly maximumInputRows: "MaximumInputRows";
+    readonly maximumOutputRows: "MaximumOutputRows";
+    readonly maximumFanOut: "MaximumFanOut";
+    readonly maximumPageSize: "MaximumPageSize";
+    readonly maximumFieldPathDepth: "MaximumFieldPathDepth";
+    readonly maximumExpressionDepth: "MaximumExpressionDepth";
+    readonly maximumBatchSize: "MaximumBatchSize";
+    readonly singleSource: "SingleSource";
+    readonly singlePartition: "SinglePartition";
+    readonly materializedInputs: "MaterializedInputs";
+    readonly completeInputEvidence: "CompleteInputEvidence";
+    readonly nonNullOperands: "NonNullOperands";
+    readonly scalarOperands: "ScalarOperands";
+    readonly homogeneousTemporalDomain: "HomogeneousTemporalDomain";
+    readonly finiteTemporalBounds: "FiniteTemporalBounds";
+    readonly stableUniqueOrdering: "StableUniqueOrdering";
+    readonly deterministicProvider: "DeterministicProvider";
+    readonly exactNumericAggregateDomain: "ExactNumericAggregateDomain";
+    readonly exactTemporalDomain: "ExactTemporalDomain";
+    readonly suppliedRelationRoot: "SuppliedRelationRoot";
+};
+export declare const relationQueryOperatingBoundaryKindLabels: Record<RelationQueryOperatingBoundaryKind, string>;
+export type RelationDraftId = string;
+export type RelationId = string;
+export type RelationName = string;
+export interface LogicalQueryDefinition {
+    nodes: LogicalQueryNode[];
+    parameters: QueryParameterDefinition[];
+}
+export interface RelationDraftProjection {
+    id: QueryNodeId;
+    input: QueryNodeId;
+    resultBinding: ValueBindingId;
+    resultShape: QualifiedShapeId;
+    assignments: RelationDraftAssignmentSlot[];
+}
+export type RelationOutputMode = 'OnePerRoot' | 'ZeroOrOnePerRoot' | 'ManyPerRoot' | 'Set';
+export declare const relationOutputModes: {
+    readonly onePerRoot: "OnePerRoot";
+    readonly zeroOrOnePerRoot: "ZeroOrOnePerRoot";
+    readonly manyPerRoot: "ManyPerRoot";
+    readonly set: "Set";
+};
+export declare const relationOutputModeLabels: Record<RelationOutputMode, string>;
 export type Expr = {
+    readonly $expr: 'binding';
+} & BindingExpr | {
     readonly $expr: 'field';
 } & FieldExpr | {
     readonly $expr: 'currentItem';
@@ -44,125 +805,543 @@ export type Expr = {
 } & LiteralExpr | {
     readonly $expr: 'aggregate';
 } & AggregateExpr;
+export interface BindingExpr {
+    binding: ValueBindingId;
+}
 export interface FieldExpr {
-    Path: FieldPath;
+    path: FieldPath;
+    binding?: ValueBindingId | null;
 }
 export type CurrentItemExpr = Record<never, never>;
 export interface ParameterExpr {
-    Parameter: string;
+    parameter: string;
 }
 export interface ConstantExpr {
-    Value: unknown;
+    value: unknown;
 }
 export interface UnaryExpr {
-    Operator: UnaryOperator;
-    Operand: Expr;
+    operator: UnaryOperator;
+    operand: Expr;
 }
 export interface BinaryExpr {
-    Operator: BinaryOperator;
-    Left: Expr;
-    Right: Expr;
+    operator: BinaryOperator;
+    left: Expr;
+    right: Expr;
 }
 export interface ConditionalExpr {
-    Test: Expr;
-    IfTrue: Expr;
-    IfFalse: Expr;
-    ReturnType: TypeRef;
+    test: Expr;
+    ifTrue: Expr;
+    ifFalse: Expr;
+    returnType: TypeRef;
 }
 export interface CallExpr {
-    Function: string;
-    Arguments: Expr[];
-    ReturnType: TypeRef;
+    function: string;
+    arguments: Expr[];
+    returnType: TypeRef;
 }
 export interface FieldRefExpr {
-    Path: FieldPath;
-    Type: TypeRef;
+    path: FieldPath;
+    type: TypeRef;
 }
 export interface LiteralExpr {
-    Type: TypeRef;
-    Value: unknown;
+    type: TypeRef;
+    value: unknown;
 }
 export interface AggregateExpr {
-    Operator: AggregateOperator;
-    Source: Expr;
-    GroupBy: Expr[];
-    ReturnType: TypeRef;
-}
-export interface MappingDefinition {
-    Id: MappingId;
-    Name: MappingName;
-    Kind: MappingKind;
-    SourceShapeId?: ShapeId | null;
-    TargetShapeId: ShapeId;
-    Assignments: FieldAssignment[];
-    Predicate?: Expr | null;
-    ForEach?: Expr | null;
-    Key?: Expr | null;
-    Entity?: Expr | null;
-    Scope: MappingScope;
-    Direction: MappingDirection;
-    NestedMappings: NestedMapping[];
-    CollectionMappings: CollectionMapping[];
-    Metadata: MappingMetadata;
-}
-export interface MaterializationSpec {
-    IsEnabled: boolean;
-    Strategy: MaterializationStrategy;
-    Freshness: FreshnessPolicy;
-    AllowCodegen: boolean;
-}
-export interface RelationMetadata {
-    AllowCodegen: boolean;
-    Deterministic: boolean;
-    Hints: ({
-        Key: string;
-        Value: string;
-    })[];
+    operator: AggregateOperator;
+    source: Expr;
+    groupBy: Expr[];
+    returnType: TypeRef;
 }
 export interface InvariantDefinition {
-    Name: string;
-    Expression: Expr;
-    Message?: string | null;
+    name: string;
+    entity?: EntityId | null;
+    expression: Expr;
+    message?: string | null;
 }
-export interface SourceAlias {
-    Value: string;
+export type DocumentOrigin = 'Unknown' | 'User' | 'System' | 'Imported' | 'Generated' | 'Compiled' | 'Extracted';
+export declare const documentOrigins: {
+    readonly unknown: "Unknown";
+    readonly user: "User";
+    readonly system: "System";
+    readonly imported: "Imported";
+    readonly generated: "Generated";
+    readonly compiled: "Compiled";
+    readonly extracted: "Extracted";
+};
+export declare const documentOriginLabels: Record<DocumentOrigin, string>;
+export type AnnotationKey = string;
+export type AnnotationValue = unknown;
+export interface RelationDraftProducerArtifactReference {
+    kind: string;
+    value: string;
+}
+export interface RelationDraftConventionDecision {
+    ruleId: string;
+    slotId: QueryAssignmentId;
+    candidateId?: RelationDraftCandidateId | null;
+    sourceBinding: ValueBindingId;
+    source?: FieldPath | null;
+    target: FieldPath;
+}
+export interface RelationOutputDefinition {
+    node: QueryNodeId;
+    shape: QualifiedShapeId;
+    mode: RelationOutputMode;
+    key?: Expr | null;
+}
+export type QueryId = string;
+export type QueryName = string;
+export type QueryResultDefinition = {
+    readonly $result: 'rows';
+} & RowsQueryResultDefinition | {
+    readonly $result: 'aggregation';
+} & AggregationQueryResultDefinition;
+export interface RowsQueryResultDefinition {
+    id: QueryResultId;
+    input: QueryNodeId;
+}
+export interface AggregationQueryResultDefinition {
+    id: QueryResultId;
+    input: QueryNodeId;
+}
+export interface RelationshipDefinition {
+    id: RelationshipId;
+    sourceShape: QualifiedShapeId;
+    sourceReference: FieldPath;
+    targetShape: QualifiedShapeId;
+    targetKey: RelationshipTargetKey;
+    sourceReferenceUniqueness: SourceReferenceUniqueness;
+}
+export interface RelationQueryLogicalPlan {
+    nodes: RelationQueryLogicalPlanNode[];
+    retainedNodes: QueryNodeId[];
+    evaluationOrder: QueryNodeId[];
 }
-export type SourceCardinality = 0 | 1;
-export declare const sourceCardinalities: {
-    readonly single: 0;
-    readonly many: 1;
+export interface RelationQueryExplainRequirementGraph {
+    inputs: RelationQueryExplainRequirementInput[];
+    outputs: RelationQueryOutputReference[];
+    edges: RelationQueryExplainRequirementEdge[];
+}
+export interface RelationQueryNativeResultBranch {
+    id: RelationQueryNativeResultBranchId;
+    kind: RelationQueryNativeResultKind;
+    node: QueryNodeId;
+    binding: ValueBindingId;
+    shape: QualifiedShapeId;
+    relation?: RelationId | null;
+    queryResult?: QueryResultId | null;
+    outputs: RelationQueryOutputReference[];
+    fields: RelationQueryFieldReference[];
+}
+export interface DocumentDiagnosticEvidence {
+    stage?: string | null;
+    subject?: string | null;
+    relatedLocations: string[];
+    sourceReferences: string[];
+    resolutionOptions: string[];
+    expected?: string | null;
+    observed?: string | null;
+}
+export type RelationQueryPhysicalPlanningStatus = 'Planned' | 'Unavailable' | 'Invalid';
+export declare const relationQueryPhysicalPlanningStatuses: {
+    readonly planned: "Planned";
+    readonly unavailable: "Unavailable";
+    readonly invalid: "Invalid";
 };
-export declare const sourceCardinalityLabels: Record<SourceCardinality, string>;
-export type JoinKind = 0 | 1 | 2 | 3;
-export declare const joinKinds: {
-    readonly inner: 0;
-    readonly left: 1;
-    readonly right: 2;
-    readonly full: 3;
+export declare const relationQueryPhysicalPlanningStatusLabels: Record<RelationQueryPhysicalPlanningStatus, string>;
+export type RelationQueryNativeCompilationStatus = 'Exact' | 'Unsupported' | 'Invalid';
+export declare const relationQueryNativeCompilationStatuses: {
+    readonly exact: "Exact";
+    readonly unsupported: "Unsupported";
+    readonly invalid: "Invalid";
 };
-export declare const joinKindLabels: Record<JoinKind, string>;
-export interface FieldPath {
-    Segments: FieldPathSegment[];
+export declare const relationQueryNativeCompilationStatusLabels: Record<RelationQueryNativeCompilationStatus, string>;
+export interface RelationQueryNativeArtifactReference {
+    branch: RelationQueryNativeResultBranchId;
+    artifactSchemaVersion?: string | null;
+    fingerprint: RelationQueryNativeArtifactFingerprintReference;
+    provenance: RelationQueryNativeCompilationProvenance;
 }
-export type UnaryOperator = 0;
+export interface RelationQueryNativeCompilationDiagnostic {
+    code: string;
+    severity: DiagnosticSeverity;
+    message: string;
+    branch?: RelationQueryNativeResultBranchId | null;
+    node?: QueryNodeId | null;
+    input?: RelationQueryInputId | null;
+    requirement?: RelationQueryRealizationRequirementId | null;
+    capabilityEvidence?: RelationQueryTargetCapabilityEvidenceId | null;
+    operatingBoundary?: RelationQueryOperatingBoundaryId | null;
+    override?: RelationQueryRealizationOverrideId | null;
+    semanticSite?: string | null;
+    contextEvidence?: RelationQueryContextEvidenceId | null;
+    field?: FieldPath | null;
+    placementBinding?: RelationQuerySourcePlacementBindingId | null;
+    bindingSetting?: string | null;
+    resolution?: string | null;
+    configurationOrigin?: EffectiveConfigurationOrigin | null;
+    configurationAuthority?: string | null;
+    adapterDecisionCode?: RelationQueryAdapterDecisionCode | null;
+}
+export interface RelationQueryEvaluationFingerprint {
+    algorithm: string;
+    canonicalization: string;
+    value: string;
+}
+export type RelationQueryExecutionStatus = 'Succeeded' | 'Incomplete' | 'Failed';
+export declare const relationQueryExecutionStatuses: {
+    readonly succeeded: "Succeeded";
+    readonly incomplete: "Incomplete";
+    readonly failed: "Failed";
+};
+export declare const relationQueryExecutionStatusLabels: Record<RelationQueryExecutionStatus, string>;
+export interface RelationQueryExplainResultSummary {
+    branch: RelationQueryNativeResultBranchId;
+    kind: RelationQueryExecutionResultKind;
+    shape: QualifiedShapeId;
+    state: RelationQueryExecutionOutputState;
+    rowCount: number;
+}
+export interface RelationQueryExplainRequirementGapSummary {
+    cause: RelationRequirementGapCause;
+    input: RelationQueryInputId;
+    affectedOutputs: RelationQueryOutputId[];
+    occurrenceCount: number;
+    suggestedResolutions: RelationRequirementGapResolutionKind[];
+}
+export interface RelationQueryEvaluationObservationFingerprint {
+    algorithm: string;
+    canonicalization: string;
+    value: string;
+}
+export interface FieldPathSegment {
+    kind: SegmentKind;
+    segment?: string | null;
+}
+export type RelationQueryPhysicalLoweringRuleId = string;
+export interface RelationQueryPhysicalCapabilityEvidenceReference {
+    source: RelationQuerySourceInstanceId;
+    target: RelationQueryTargetId;
+    profile: RelationQueryTargetProfileId;
+    evidence: RelationQueryTargetCapabilityEvidenceId;
+}
+export type RelationQueryPhysicalPlanningDecisionId = string;
+export interface RelationQueryAdapterBindingFingerprint {
+    algorithm: string;
+    canonicalization: string;
+    value: string;
+}
+export type RelationQueryBoundAssessmentStatus = 'Available' | 'Unavailable' | 'Invalid' | 'Blocked';
+export declare const relationQueryBoundAssessmentStatuses: {
+    readonly available: "Available";
+    readonly unavailable: "Unavailable";
+    readonly invalid: "Invalid";
+    readonly blocked: "Blocked";
+};
+export declare const relationQueryBoundAssessmentStatusLabels: Record<RelationQueryBoundAssessmentStatus, string>;
+export type RelationQueryLogicalCapabilityKind = 'Source' | 'Filter' | 'RelationshipTraversal' | 'ForwardRelationshipTraversal' | 'InverseRelationshipTraversal' | 'AtMostOneRelationshipTraversal' | 'ManyRelationshipTraversal' | 'RequiredRelationshipTraversal' | 'OptionalRelationshipTraversal' | 'Join' | 'InnerJoin' | 'LeftOuterJoin' | 'RightOuterJoin' | 'FullOuterJoin' | 'TemporalJoin' | 'ExpandCollection' | 'Projection' | 'ProjectionAssignment' | 'DistinctRows' | 'DistinctKeys' | 'Aggregation' | 'AggregateGrouping' | 'AggregateFilter' | 'CountAggregate' | 'SumAggregate' | 'MinimumAggregate' | 'MaximumAggregate' | 'AnyAggregate' | 'AllAggregate' | 'Ordering' | 'AscendingOrdering' | 'DescendingOrdering' | 'NullsFirst' | 'NullsLast' | 'StableTieOrdering' | 'OffsetPaging' | 'KeysetPaging' | 'OnePerRootRelationOutput' | 'ZeroOrOnePerRootRelationOutput' | 'ManyPerRootRelationOutput' | 'SetRelationOutput' | 'RelationOutputIdentity' | 'RelationInvariant' | 'QueryRowsResult' | 'QueryAggregationResult' | 'AlwaysPresentBinding' | 'MayBeAbsentBinding' | 'AverageAggregate';
+export declare const relationQueryLogicalCapabilityKinds: {
+    readonly source: "Source";
+    readonly filter: "Filter";
+    readonly relationshipTraversal: "RelationshipTraversal";
+    readonly forwardRelationshipTraversal: "ForwardRelationshipTraversal";
+    readonly inverseRelationshipTraversal: "InverseRelationshipTraversal";
+    readonly atMostOneRelationshipTraversal: "AtMostOneRelationshipTraversal";
+    readonly manyRelationshipTraversal: "ManyRelationshipTraversal";
+    readonly requiredRelationshipTraversal: "RequiredRelationshipTraversal";
+    readonly optionalRelationshipTraversal: "OptionalRelationshipTraversal";
+    readonly join: "Join";
+    readonly innerJoin: "InnerJoin";
+    readonly leftOuterJoin: "LeftOuterJoin";
+    readonly rightOuterJoin: "RightOuterJoin";
+    readonly fullOuterJoin: "FullOuterJoin";
+    readonly temporalJoin: "TemporalJoin";
+    readonly expandCollection: "ExpandCollection";
+    readonly projection: "Projection";
+    readonly projectionAssignment: "ProjectionAssignment";
+    readonly distinctRows: "DistinctRows";
+    readonly distinctKeys: "DistinctKeys";
+    readonly aggregation: "Aggregation";
+    readonly aggregateGrouping: "AggregateGrouping";
+    readonly aggregateFilter: "AggregateFilter";
+    readonly countAggregate: "CountAggregate";
+    readonly sumAggregate: "SumAggregate";
+    readonly minimumAggregate: "MinimumAggregate";
+    readonly maximumAggregate: "MaximumAggregate";
+    readonly anyAggregate: "AnyAggregate";
+    readonly allAggregate: "AllAggregate";
+    readonly ordering: "Ordering";
+    readonly ascendingOrdering: "AscendingOrdering";
+    readonly descendingOrdering: "DescendingOrdering";
+    readonly nullsFirst: "NullsFirst";
+    readonly nullsLast: "NullsLast";
+    readonly stableTieOrdering: "StableTieOrdering";
+    readonly offsetPaging: "OffsetPaging";
+    readonly keysetPaging: "KeysetPaging";
+    readonly onePerRootRelationOutput: "OnePerRootRelationOutput";
+    readonly zeroOrOnePerRootRelationOutput: "ZeroOrOnePerRootRelationOutput";
+    readonly manyPerRootRelationOutput: "ManyPerRootRelationOutput";
+    readonly setRelationOutput: "SetRelationOutput";
+    readonly relationOutputIdentity: "RelationOutputIdentity";
+    readonly relationInvariant: "RelationInvariant";
+    readonly queryRowsResult: "QueryRowsResult";
+    readonly queryAggregationResult: "QueryAggregationResult";
+    readonly alwaysPresentBinding: "AlwaysPresentBinding";
+    readonly mayBeAbsentBinding: "MayBeAbsentBinding";
+    readonly averageAggregate: "AverageAggregate";
+};
+export declare const relationQueryLogicalCapabilityKindLabels: Record<RelationQueryLogicalCapabilityKind, string>;
+export interface ExprCapabilityId {
+    value: string;
+}
+export type ExprCapabilityRequirementKind = 'Operation' | 'Ambient';
+export declare const exprCapabilityRequirementKinds: {
+    readonly operation: "Operation";
+    readonly ambient: "Ambient";
+};
+export declare const exprCapabilityRequirementKindLabels: Record<ExprCapabilityRequirementKind, string>;
+export type RelationQueryTemporalExecutionCapability = 'PointInInterval' | 'IntervalOverlap' | 'InclusiveBoundary' | 'ExclusiveBoundary' | 'UnboundedBoundary' | 'NullAsUnbounded' | 'DateDomain' | 'DateTimeDomain' | 'InstantDomain' | 'PreserveAllMatches' | 'InnerJoin' | 'LeftOuterJoin' | 'RightOuterJoin' | 'FullOuterJoin' | 'ValidateIntervals' | 'InconclusiveEvidence';
+export declare const relationQueryTemporalExecutionCapabilities: {
+    readonly pointInInterval: "PointInInterval";
+    readonly intervalOverlap: "IntervalOverlap";
+    readonly inclusiveBoundary: "InclusiveBoundary";
+    readonly exclusiveBoundary: "ExclusiveBoundary";
+    readonly unboundedBoundary: "UnboundedBoundary";
+    readonly nullAsUnbounded: "NullAsUnbounded";
+    readonly dateDomain: "DateDomain";
+    readonly dateTimeDomain: "DateTimeDomain";
+    readonly instantDomain: "InstantDomain";
+    readonly preserveAllMatches: "PreserveAllMatches";
+    readonly innerJoin: "InnerJoin";
+    readonly leftOuterJoin: "LeftOuterJoin";
+    readonly rightOuterJoin: "RightOuterJoin";
+    readonly fullOuterJoin: "FullOuterJoin";
+    readonly validateIntervals: "ValidateIntervals";
+    readonly inconclusiveEvidence: "InconclusiveEvidence";
+};
+export declare const relationQueryTemporalExecutionCapabilityLabels: Record<RelationQueryTemporalExecutionCapability, string>;
+export type RelationQueryStructuralCapabilityRole = 'BindingRead' | 'CurrentItemRead' | 'OccurrenceEvidenceReconstruction' | 'ProjectionTarget' | 'GroupingTarget' | 'AggregateTarget' | 'OutputSelection' | 'CompleteValue';
+export declare const relationQueryStructuralCapabilityRoles: {
+    readonly bindingRead: "BindingRead";
+    readonly currentItemRead: "CurrentItemRead";
+    readonly occurrenceEvidenceReconstruction: "OccurrenceEvidenceReconstruction";
+    readonly projectionTarget: "ProjectionTarget";
+    readonly groupingTarget: "GroupingTarget";
+    readonly aggregateTarget: "AggregateTarget";
+    readonly outputSelection: "OutputSelection";
+    readonly completeValue: "CompleteValue";
+};
+export declare const relationQueryStructuralCapabilityRoleLabels: Record<RelationQueryStructuralCapabilityRole, string>;
+export type RelationQueryStructuralPathKind = 'RootValue' | 'TopLevelField' | 'NestedField' | 'CollectionElement' | 'NestedCollectionElement';
+export declare const relationQueryStructuralPathKinds: {
+    readonly rootValue: "RootValue";
+    readonly topLevelField: "TopLevelField";
+    readonly nestedField: "NestedField";
+    readonly collectionElement: "CollectionElement";
+    readonly nestedCollectionElement: "NestedCollectionElement";
+};
+export declare const relationQueryStructuralPathKindLabels: Record<RelationQueryStructuralPathKind, string>;
+export type RelationQueryPrimitiveCapabilityKind = 'KeyExtraction' | 'BatchedKeyLookup' | 'PredicateRead' | 'CompleteSetEnumeration' | 'LocalCorrelation' | 'HashJoin' | 'StableSort' | 'LocalAggregation' | 'FieldProjection' | 'NullAwareComparison' | 'TemporalComparison' | 'IntervalPredicate' | 'ObservationIdentityRead' | 'RelationshipReferenceRead' | 'ParameterBinding' | 'AmbientCapabilityBinding' | 'OutputObjectConstruction' | 'ProvenanceTracking' | 'BatchedPredicateLookup' | 'InvariantEvaluation' | 'OffsetPaging' | 'KeysetSeek';
+export declare const relationQueryPrimitiveCapabilityKinds: {
+    readonly keyExtraction: "KeyExtraction";
+    readonly batchedKeyLookup: "BatchedKeyLookup";
+    readonly predicateRead: "PredicateRead";
+    readonly completeSetEnumeration: "CompleteSetEnumeration";
+    readonly localCorrelation: "LocalCorrelation";
+    readonly hashJoin: "HashJoin";
+    readonly stableSort: "StableSort";
+    readonly localAggregation: "LocalAggregation";
+    readonly fieldProjection: "FieldProjection";
+    readonly nullAwareComparison: "NullAwareComparison";
+    readonly temporalComparison: "TemporalComparison";
+    readonly intervalPredicate: "IntervalPredicate";
+    readonly observationIdentityRead: "ObservationIdentityRead";
+    readonly relationshipReferenceRead: "RelationshipReferenceRead";
+    readonly parameterBinding: "ParameterBinding";
+    readonly ambientCapabilityBinding: "AmbientCapabilityBinding";
+    readonly outputObjectConstruction: "OutputObjectConstruction";
+    readonly provenanceTracking: "ProvenanceTracking";
+    readonly batchedPredicateLookup: "BatchedPredicateLookup";
+    readonly invariantEvaluation: "InvariantEvaluation";
+    readonly offsetPaging: "OffsetPaging";
+    readonly keysetSeek: "KeysetSeek";
+};
+export declare const relationQueryPrimitiveCapabilityKindLabels: Record<RelationQueryPrimitiveCapabilityKind, string>;
+export interface RelationQueryRealizationOutputReference {
+    id: RelationQueryOutputId;
+    kind: RelationQueryOutputReferenceKind;
+    node: QueryNodeId;
+    shape: QualifiedShapeId;
+    relation?: RelationId | null;
+    queryResult?: QueryResultId | null;
+    field?: RelationQueryFieldReference | null;
+}
+export type RelationQueryRequirementEffect = 'Value' | 'Identity' | 'Membership' | 'Correlation' | 'Acquisition' | 'Cardinality' | 'Ordering' | 'Grouping' | 'Aggregation' | 'Pagination' | 'Validation' | 'Evaluation';
+export declare const relationQueryRequirementEffects: {
+    readonly value: "Value";
+    readonly identity: "Identity";
+    readonly membership: "Membership";
+    readonly correlation: "Correlation";
+    readonly acquisition: "Acquisition";
+    readonly cardinality: "Cardinality";
+    readonly ordering: "Ordering";
+    readonly grouping: "Grouping";
+    readonly aggregation: "Aggregation";
+    readonly pagination: "Pagination";
+    readonly validation: "Validation";
+    readonly evaluation: "Evaluation";
+};
+export declare const relationQueryRequirementEffectLabels: Record<RelationQueryRequirementEffect, string>;
+export type QueryInputRequirement = 'Optional' | 'Required';
+export declare const queryInputRequirements: {
+    readonly optional: "Optional";
+    readonly required: "Required";
+};
+export declare const queryInputRequirementLabels: Record<QueryInputRequirement, string>;
+export interface RelationQueryRealizationTrace {
+    steps: RelationQueryRealizationTraceStep[];
+}
+export type RelationQueryRealizationStaticFactKind = 'FieldPathDepth' | 'ExpressionDepth' | 'PageSize';
+export declare const relationQueryRealizationStaticFactKinds: {
+    readonly fieldPathDepth: "FieldPathDepth";
+    readonly expressionDepth: "ExpressionDepth";
+    readonly pageSize: "PageSize";
+};
+export declare const relationQueryRealizationStaticFactKindLabels: Record<RelationQueryRealizationStaticFactKind, string>;
+export type RelationQueryOperatingBoundaryValidationKind = 'StaticPlanFact' | 'TargetEnforced';
+export declare const relationQueryOperatingBoundaryValidationKinds: {
+    readonly staticPlanFact: "StaticPlanFact";
+    readonly targetEnforced: "TargetEnforced";
+};
+export declare const relationQueryOperatingBoundaryValidationKindLabels: Record<RelationQueryOperatingBoundaryValidationKind, string>;
+export type LogicalQueryNode = {
+    readonly $node: 'source';
+} & SourceQueryNode | {
+    readonly $node: 'filter';
+} & FilterQueryNode | {
+    readonly $node: 'traverseRelationship';
+} & TraverseRelationshipQueryNode | {
+    readonly $node: 'join';
+} & JoinQueryNode | {
+    readonly $node: 'temporalJoin';
+} & TemporalJoinQueryNode | {
+    readonly $node: 'expandCollection';
+} & ExpandCollectionQueryNode | {
+    readonly $node: 'project';
+} & ProjectQueryNode | {
+    readonly $node: 'distinct';
+} & DistinctQueryNode | {
+    readonly $node: 'aggregate';
+} & AggregateQueryNode | {
+    readonly $node: 'order';
+} & OrderQueryNode | {
+    readonly $node: 'page';
+} & PageQueryNode;
+export interface SourceQueryNode {
+    id: QueryNodeId;
+    binding: ValueBindingId;
+    shape: QualifiedShapeId;
+}
+export interface FilterQueryNode {
+    input: QueryNodeId;
+    predicate: Expr;
+    id: QueryNodeId;
+}
+export interface TraverseRelationshipQueryNode {
+    id: QueryNodeId;
+    input: QueryNodeId;
+    from: ValueBindingId;
+    relationship: RelationshipId;
+    direction: RelationshipTraversalDirection;
+    result: ValueBindingId;
+    joinKind: JoinKind;
+    requirement: QueryInputRequirement;
+}
+export interface JoinQueryNode {
+    left: QueryNodeId;
+    right: QueryNodeId;
+    kind: JoinKind;
+    predicate: Expr;
+    id: QueryNodeId;
+}
+export interface TemporalJoinQueryNode {
+    id: QueryNodeId;
+    left: QueryNodeId;
+    right: QueryNodeId;
+    kind: JoinKind;
+    correlation: Expr;
+    match: TemporalJoinMatch;
+}
+export interface ExpandCollectionQueryNode {
+    input: QueryNodeId;
+    collection: Expr;
+    itemBinding: ValueBindingId;
+    itemType: TypeRef;
+    id: QueryNodeId;
+}
+export interface ProjectQueryNode {
+    id: QueryNodeId;
+    input: QueryNodeId;
+    resultBinding: ValueBindingId;
+    resultShape: QualifiedShapeId;
+    assignments: ProjectionAssignment[];
+}
+export interface DistinctQueryNode {
+    input: QueryNodeId;
+    keys: Expr[];
+    id: QueryNodeId;
+}
+export interface AggregateQueryNode {
+    input: QueryNodeId;
+    resultBinding: ValueBindingId;
+    resultShape: QualifiedShapeId;
+    groupings: QueryGrouping[];
+    aggregates: QueryAggregateAssignment[];
+    id: QueryNodeId;
+}
+export interface OrderQueryNode {
+    id: QueryNodeId;
+    input: QueryNodeId;
+    orderings: QueryOrdering[];
+}
+export interface PageQueryNode {
+    id: QueryNodeId;
+    input: QueryNodeId;
+    page: QueryPageDefinition;
+}
+export interface QueryParameterDefinition {
+    id: QueryParameterId;
+    type: TypeRef;
+    presence: FieldPresence;
+    defaultKind: QueryParameterDefaultKind;
+    defaultValue?: unknown | null;
+}
+export interface RelationDraftAssignmentSlot {
+    id: QueryAssignmentId;
+    target: FieldPath;
+    candidates: RelationDraftCandidate[];
+    resolution: RelationDraftAssignmentResolution;
+}
+export type UnaryOperator = 'Not';
 export declare const unaryOperators: {
-    readonly not: 0;
+    readonly not: "Not";
 };
 export declare const unaryOperatorLabels: Record<UnaryOperator, string>;
-export type BinaryOperator = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11;
+export type BinaryOperator = 'Eq' | 'Ne' | 'Gt' | 'Ge' | 'Lt' | 'Le' | 'And' | 'Or' | 'Add' | 'Sub' | 'Mul' | 'Div';
 export declare const binaryOperators: {
-    readonly eq: 0;
-    readonly ne: 1;
-    readonly gt: 2;
-    readonly ge: 3;
-    readonly lt: 4;
-    readonly le: 5;
-    readonly and: 6;
-    readonly or: 7;
-    readonly add: 8;
-    readonly sub: 9;
-    readonly mul: 10;
-    readonly div: 11;
+    readonly eq: "Eq";
+    readonly ne: "Ne";
+    readonly gt: "Gt";
+    readonly ge: "Ge";
+    readonly lt: "Lt";
+    readonly le: "Le";
+    readonly and: "And";
+    readonly or: "Or";
+    readonly add: "Add";
+    readonly sub: "Sub";
+    readonly mul: "Mul";
+    readonly div: "Div";
 };
 export declare const binaryOperatorLabels: Record<BinaryOperator, string>;
 export type TypeRef = {
@@ -185,206 +1364,564 @@ export type TypeRef = {
     readonly $type: 'json';
 } & JsonTypeRef;
 export interface NamedTypeRef {
-    TypeId: TypeId;
+    typeId: TypeId;
 }
 export interface OpaqueRuntimeTypeRef {
-    RuntimeType: string;
+    runtimeType: string;
+    inferenceDiagnostic?: TypeInferenceDiagnostic | null;
 }
 export interface ScalarTypeRef {
-    Kind: ScalarTypeKind;
-    Format: PrimitiveFormat;
+    kind: ScalarTypeKind;
+    format: PrimitiveFormat;
 }
 export interface EnumTypeRef {
-    Name: string;
-    Members: string[];
+    name: string;
+    members: string[];
 }
 export interface EntityReferenceTypeRef {
-    Entity: EntityTypeName;
+    entity: EntityTypeName;
 }
 export interface ArrayTypeRef {
-    ElementType: TypeRef;
+    elementType: TypeRef;
 }
 export interface ObjectTypeRef {
-    Fields: ObjectFieldTypeDef[];
+    fields: ObjectFieldTypeDef[];
 }
 export interface QuantityTypeRef {
-    Quantity: string;
-    BaseKind: ScalarTypeKind;
+    quantity: string;
+    baseKind: ScalarTypeKind;
 }
 export interface JsonTypeRef {
-    Kind: JsonTypeKind;
+    kind: JsonTypeKind;
 }
-export type AggregateOperator = 0 | 1 | 2 | 3 | 4 | 5;
+export type AggregateOperator = 'Count' | 'Sum' | 'Min' | 'Max' | 'Any' | 'All' | 'Average';
 export declare const aggregateOperators: {
-    readonly count: 0;
-    readonly sum: 1;
-    readonly min: 2;
-    readonly max: 3;
-    readonly any: 4;
-    readonly all: 5;
+    readonly count: "Count";
+    readonly sum: "Sum";
+    readonly min: "Min";
+    readonly max: "Max";
+    readonly any: "Any";
+    readonly all: "All";
+    readonly average: "Average";
 };
 export declare const aggregateOperatorLabels: Record<AggregateOperator, string>;
-export interface MappingId {
-    Value: string;
-}
-export interface MappingName {
-    Value: string;
-}
-export type MappingKind = 0 | 1;
-export declare const mappingKinds: {
-    readonly relation: 0;
-    readonly object: 1;
-};
-export declare const mappingKindLabels: Record<MappingKind, string>;
-export interface FieldAssignment {
-    Id?: string | null;
-    TargetField: string;
-    Expr: Expr;
-}
-export type MappingScope = 0 | 1;
-export declare const mappingScopes: {
-    readonly rooted: 0;
-    readonly set: 1;
-};
-export declare const mappingScopeLabels: Record<MappingScope, string>;
-export type MappingDirection = 0 | 1 | 2;
-export declare const mappingDirections: {
-    readonly sourceToTarget: 0;
-    readonly targetToSource: 1;
-    readonly bidirectional: 2;
-};
-export declare const mappingDirectionLabels: Record<MappingDirection, string>;
-export interface NestedMapping {
-    Source: FieldPath;
-    Target: FieldPath;
-    NestedMappingId: MappingId;
-}
-export interface CollectionMapping {
-    SourceCollection: FieldPath;
-    TargetCollection: FieldPath;
-    ItemMappingId: MappingId;
-}
-export interface MappingMetadata {
-    AllowCodegen: boolean;
-    Deterministic: boolean;
-    TransportMapping: boolean;
-    ExecutionPreference: MappingExecutionPreference;
-    Hints: ({
-        Key: string;
-        Value: string;
-    })[];
-}
-export type MaterializationStrategy = 0 | 1 | 2 | 3;
-export declare const materializationStrategies: {
-    readonly onDemand: 0;
-    readonly asyncIndex: 1;
-    readonly changeFeed: 2;
-    readonly snapshot: 3;
-};
-export declare const materializationStrategyLabels: Record<MaterializationStrategy, string>;
-export type FreshnessPolicy = 0 | 1 | 2;
-export declare const freshnessPolicies: {
-    readonly strong: 0;
-    readonly eventual: 1;
-    readonly boundedStaleness: 2;
-};
-export declare const freshnessPolicyLabels: Record<FreshnessPolicy, string>;
-export interface FieldPathSegment {
-    Kind: SegmentKind;
-    Segment?: string | null;
+export type EntityId = string;
+export type QueryAssignmentId = string;
+export type RelationDraftCandidateId = string;
+export type QueryResultId = string;
+export type RelationshipId = string;
+export type RelationshipTargetKey = {
+    readonly $targetKey: 'observationIdentity';
+} & ObservationIdentityRelationshipTargetKey;
+export type ObservationIdentityRelationshipTargetKey = Record<never, never>;
+export type SourceReferenceUniqueness = 'NotGuaranteed' | 'GloballyUnique';
+export declare const sourceReferenceUniquenesses: {
+    readonly notGuaranteed: "NotGuaranteed";
+    readonly globallyUnique: "GloballyUnique";
+};
+export declare const sourceReferenceUniquenessLabels: Record<SourceReferenceUniqueness, string>;
+export interface RelationQueryLogicalPlanNode {
+    node: QueryNodeId;
+    inputs: RelationQueryLogicalPlanInput[];
+    effectiveInputs: QueryNodeId[];
+}
+export interface RelationQueryExplainRequirementInput {
+    id: RelationQueryInputId;
+    kind: RelationQueryExplainRequirementInputKind;
+}
+export interface RelationQueryOutputReference {
+    id: RelationQueryOutputId;
+    kind: RelationQueryOutputReferenceKind;
+    node: QueryNodeId;
+    shape: QualifiedShapeId;
+    relation?: RelationId | null;
+    queryResult?: QueryResultId | null;
+    field?: RelationQueryFieldReference | null;
+}
+export interface RelationQueryExplainRequirementEdge {
+    input: RelationQueryInputId;
+    output: RelationQueryOutputId;
+    effect: RelationQueryRequirementEffect;
+    requirement: QueryInputRequirement;
+}
+export type RelationQueryNativeResultKind = 'RelationRows' | 'QueryRows' | 'QueryAggregation';
+export declare const relationQueryNativeResultKinds: {
+    readonly relationRows: "RelationRows";
+    readonly queryRows: "QueryRows";
+    readonly queryAggregation: "QueryAggregation";
+};
+export declare const relationQueryNativeResultKindLabels: Record<RelationQueryNativeResultKind, string>;
+export interface RelationQueryFieldReference {
+    shape: QualifiedShapeId;
+    path: FieldPath;
+}
+export interface RelationQueryNativeArtifactFingerprintReference {
+    algorithm: string;
+    canonicalization: string;
+    value: string;
+}
+export interface RelationQueryNativeCompilationProvenance {
+    plan: RelationQueryCompiledPlanReference;
+    branch: RelationQueryNativeResultBranchId;
+    target: RelationQueryTargetId;
+    targetProfile: RelationQueryTargetProfileId;
+    realization: RelationQueryRealizationFingerprint;
+    boundRealization: RelationQueryBoundRealizationFingerprint;
+    placement: RelationQuerySourcePlacementFingerprint;
+    adapterBinding: RelationQueryAdapterBindingReference;
+    contextEvidence: RelationQueryContextEvidenceId[];
+    compilerProfile: string;
+    conventionSetVersion: string;
+    coveredNodes: QueryNodeId[];
+    coveredAssignments: QueryAssignmentId[];
+    inputFields: RelationQueryInputId[];
+    realizationDecisions: RelationQueryNativeCompilationDecisionReference[];
+    capabilityEvidence: RelationQueryTargetCapabilityEvidenceId[];
+    operatingBoundaries: RelationQueryOperatingBoundaryId[];
+}
+export type RelationQueryExecutionResultKind = 'Rows' | 'Aggregation';
+export declare const relationQueryExecutionResultKinds: {
+    readonly rows: "Rows";
+    readonly aggregation: "Aggregation";
+};
+export declare const relationQueryExecutionResultKindLabels: Record<RelationQueryExecutionResultKind, string>;
+export type RelationQueryExecutionOutputState = 'Complete' | 'Suppressed' | 'Incomplete';
+export declare const relationQueryExecutionOutputStates: {
+    readonly complete: "Complete";
+    readonly suppressed: "Suppressed";
+    readonly incomplete: "Incomplete";
+};
+export declare const relationQueryExecutionOutputStateLabels: Record<RelationQueryExecutionOutputState, string>;
+export type RelationRequirementGapCause = 'InputNotProvided' | 'InputAcquisitionFailed' | 'ObservationIdentityMissing' | 'ReferenceFieldNotLoaded' | 'ReferenceValueMissing' | 'ReferenceValueNull' | 'ResolutionNotAttempted' | 'ResolutionFailed' | 'RelatedObservationNotFound' | 'RelatedObservationRejected' | 'RequiredFieldNotLoaded' | 'RequiredValueMissing' | 'RequiredValueNull' | 'CapabilityUnavailable' | 'CardinalityViolation' | 'ConversionFailure' | 'InputAcquisitionInconclusive';
+export declare const relationRequirementGapCauses: {
+    readonly inputNotProvided: "InputNotProvided";
+    readonly inputAcquisitionFailed: "InputAcquisitionFailed";
+    readonly observationIdentityMissing: "ObservationIdentityMissing";
+    readonly referenceFieldNotLoaded: "ReferenceFieldNotLoaded";
+    readonly referenceValueMissing: "ReferenceValueMissing";
+    readonly referenceValueNull: "ReferenceValueNull";
+    readonly resolutionNotAttempted: "ResolutionNotAttempted";
+    readonly resolutionFailed: "ResolutionFailed";
+    readonly relatedObservationNotFound: "RelatedObservationNotFound";
+    readonly relatedObservationRejected: "RelatedObservationRejected";
+    readonly requiredFieldNotLoaded: "RequiredFieldNotLoaded";
+    readonly requiredValueMissing: "RequiredValueMissing";
+    readonly requiredValueNull: "RequiredValueNull";
+    readonly capabilityUnavailable: "CapabilityUnavailable";
+    readonly cardinalityViolation: "CardinalityViolation";
+    readonly conversionFailure: "ConversionFailure";
+    readonly inputAcquisitionInconclusive: "InputAcquisitionInconclusive";
+};
+export declare const relationRequirementGapCauseLabels: Record<RelationRequirementGapCause, string>;
+export type RelationRequirementGapResolutionKind = 'ProvideInput' | 'LoadField' | 'ProvideReferenceValue' | 'ResolveRelationship' | 'RetryAcquisition' | 'ProvideRelatedObservation' | 'CorrectCardinality' | 'ProvideValue' | 'ProvideCapability' | 'CorrectConversion';
+export declare const relationRequirementGapResolutionKinds: {
+    readonly provideInput: "ProvideInput";
+    readonly loadField: "LoadField";
+    readonly provideReferenceValue: "ProvideReferenceValue";
+    readonly resolveRelationship: "ResolveRelationship";
+    readonly retryAcquisition: "RetryAcquisition";
+    readonly provideRelatedObservation: "ProvideRelatedObservation";
+    readonly correctCardinality: "CorrectCardinality";
+    readonly provideValue: "ProvideValue";
+    readonly provideCapability: "ProvideCapability";
+    readonly correctConversion: "CorrectConversion";
+};
+export declare const relationRequirementGapResolutionKindLabels: Record<RelationRequirementGapResolutionKind, string>;
+export type SegmentKind = 'Field' | 'Element';
+export declare const segmentKinds: {
+    readonly field: "Field";
+    readonly element: "Element";
+};
+export declare const segmentKindLabels: Record<SegmentKind, string>;
+export type RelationQueryOutputReferenceKind = 'Relation' | 'QueryResult';
+export declare const relationQueryOutputReferenceKinds: {
+    readonly relation: "Relation";
+    readonly queryResult: "QueryResult";
+};
+export declare const relationQueryOutputReferenceKindLabels: Record<RelationQueryOutputReferenceKind, string>;
+export interface RelationQueryRealizationTraceStep {
+    kind: RelationQueryRealizationTraceStepKind;
+    node: QueryNodeId;
+    siteKind?: RelationQueryExpressionSiteKind | null;
+    expressionSite?: ExprSiteId | null;
+    assignment?: QueryAssignmentId | null;
+    ordinal?: number | null;
+    invariantName?: string | null;
+}
+export type RelationshipTraversalDirection = 'Forward' | 'Inverse';
+export declare const relationshipTraversalDirections: {
+    readonly forward: "Forward";
+    readonly inverse: "Inverse";
+};
+export declare const relationshipTraversalDirectionLabels: Record<RelationshipTraversalDirection, string>;
+export type JoinKind = 'Inner' | 'Left' | 'Right' | 'Full';
+export declare const joinKinds: {
+    readonly inner: "Inner";
+    readonly left: "Left";
+    readonly right: "Right";
+    readonly full: "Full";
+};
+export declare const joinKindLabels: Record<JoinKind, string>;
+export type TemporalJoinMatch = {
+    readonly $temporalMatch: 'pointInInterval';
+} & TemporalPointInIntervalMatch | {
+    readonly $temporalMatch: 'intervalOverlap';
+} & TemporalIntervalOverlapMatch;
+export interface TemporalPointInIntervalMatch {
+    point: Expr;
+    interval: TemporalInterval;
+}
+export interface TemporalIntervalOverlapMatch {
+    left: TemporalInterval;
+    right: TemporalInterval;
+}
+export interface ProjectionAssignment {
+    id: QueryAssignmentId;
+    target: FieldPath;
+    value: Expr;
+}
+export interface QueryGrouping {
+    id: QueryAssignmentId;
+    target: FieldPath;
+    key: Expr;
+}
+export interface QueryAggregateAssignment {
+    id: QueryAssignmentId;
+    target: FieldPath;
+    operation: AggregateOperator;
+    value?: Expr | null;
+    filter?: Expr | null;
+}
+export interface QueryOrdering {
+    key: Expr;
+    direction: QuerySortDirection;
+    nullPlacement: QueryNullPlacement;
 }
-export interface TypeId {
-    Value: string;
+export type QueryPageDefinition = {
+    readonly $page: 'offset';
+} & OffsetPageDefinition | {
+    readonly $page: 'keyset';
+} & KeysetPageDefinition;
+export interface OffsetPageDefinition {
+    offset: number;
+    limit: number;
 }
-export type ScalarTypeKind = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9;
+export interface KeysetPageDefinition {
+    after: Expr[];
+    limit: number;
+}
+export type QueryParameterId = string;
+export type FieldPresence = 'Required' | 'Optional';
+export declare const fieldPresences: {
+    readonly required: "Required";
+    readonly optional: "Optional";
+};
+export declare const fieldPresenceLabels: Record<FieldPresence, string>;
+export type QueryParameterDefaultKind = 'None' | 'Value';
+export declare const queryParameterDefaultKinds: {
+    readonly none: "None";
+    readonly value: "Value";
+};
+export declare const queryParameterDefaultKindLabels: Record<QueryParameterDefaultKind, string>;
+export interface RelationDraftCandidate {
+    id: RelationDraftCandidateId;
+    value: Expr;
+}
+export type RelationDraftAssignmentResolution = {
+    readonly $resolution: 'selected';
+} & SelectedRelationDraftAssignmentResolution | {
+    readonly $resolution: 'omitted';
+} & OmittedRelationDraftAssignmentResolution | {
+    readonly $resolution: 'unresolved';
+} & UnresolvedRelationDraftAssignmentResolution | {
+    readonly $resolution: 'ambiguous';
+} & AmbiguousRelationDraftAssignmentResolution;
+export interface SelectedRelationDraftAssignmentResolution {
+    candidateId: RelationDraftCandidateId;
+}
+export type OmittedRelationDraftAssignmentResolution = Record<never, never>;
+export interface UnresolvedRelationDraftAssignmentResolution {
+    reasons: RelationDraftUnresolvedReason[];
+}
+export interface AmbiguousRelationDraftAssignmentResolution {
+    candidateIds: RelationDraftCandidateId[];
+}
+export type TypeId = string;
+export interface TypeInferenceDiagnostic {
+    reason: string;
+    message?: string | null;
+}
+export type ScalarTypeKind = 'Bool' | 'Int32' | 'Int64' | 'Decimal' | 'String' | 'Guid' | 'Date' | 'DateTime' | 'Instant' | 'Bytes';
 export declare const scalarTypeKinds: {
-    readonly bool: 0;
-    readonly int32: 1;
-    readonly int64: 2;
-    readonly decimal: 3;
-    readonly string: 4;
-    readonly guid: 5;
-    readonly date: 6;
-    readonly dateTime: 7;
-    readonly instant: 8;
-    readonly bytes: 9;
+    readonly bool: "Bool";
+    readonly int32: "Int32";
+    readonly int64: "Int64";
+    readonly decimal: "Decimal";
+    readonly string: "String";
+    readonly guid: "Guid";
+    readonly date: "Date";
+    readonly dateTime: "DateTime";
+    readonly instant: "Instant";
+    readonly bytes: "Bytes";
 };
 export declare const scalarTypeKindLabels: Record<ScalarTypeKind, string>;
-export type PrimitiveFormat = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9;
+export type PrimitiveFormat = 'None' | 'Uuid' | 'IsoDate' | 'IsoDateTime' | 'IsoInstant' | 'CurrencyCode' | 'CountryCode' | 'Email' | 'Uri' | 'Base64';
 export declare const primitiveFormats: {
-    readonly none: 0;
-    readonly uuid: 1;
-    readonly isoDate: 2;
-    readonly isoDateTime: 3;
-    readonly isoInstant: 4;
-    readonly currencyCode: 5;
-    readonly countryCode: 6;
-    readonly email: 7;
-    readonly uri: 8;
-    readonly base64: 9;
+    readonly none: "None";
+    readonly uuid: "Uuid";
+    readonly isoDate: "IsoDate";
+    readonly isoDateTime: "IsoDateTime";
+    readonly isoInstant: "IsoInstant";
+    readonly currencyCode: "CurrencyCode";
+    readonly countryCode: "CountryCode";
+    readonly email: "Email";
+    readonly uri: "Uri";
+    readonly base64: "Base64";
 };
 export declare const primitiveFormatLabels: Record<PrimitiveFormat, string>;
-export interface EntityTypeName {
-    Value: string;
-}
+export type EntityTypeName = string;
 export interface ObjectFieldTypeDef {
-    Name: string;
-    Type: TypeRef;
-    Presence: FieldPresence;
-    Annotations: ({
-        Key: AnnotationKey;
-        Value: AnnotationValue;
-    })[];
-}
-export type JsonTypeKind = 0 | 1 | 2 | 3 | 4 | 5;
+    name: string;
+    type: TypeRef;
+    cardinality: FieldCardinality;
+    presence: FieldPresence;
+    nullability: FieldNullability;
+    annotations: Record<string, AnnotationValue>;
+}
+export type JsonTypeKind = 'Any' | 'Object' | 'Array' | 'String' | 'Number' | 'Boolean';
 export declare const jsonTypeKinds: {
-    readonly any: 0;
-    readonly object: 1;
-    readonly array: 2;
-    readonly string: 3;
-    readonly number: 4;
-    readonly boolean: 5;
+    readonly any: "Any";
+    readonly object: "Object";
+    readonly array: "Array";
+    readonly string: "String";
+    readonly number: "Number";
+    readonly boolean: "Boolean";
 };
 export declare const jsonTypeKindLabels: Record<JsonTypeKind, string>;
-export type MappingExecutionPreference = 0 | 1 | 2;
-export declare const mappingExecutionPreferences: {
-    readonly inMemory: 0;
-    readonly materialized: 1;
-    readonly codeGenerated: 2;
-};
-export declare const mappingExecutionPreferenceLabels: Record<MappingExecutionPreference, string>;
-export type SegmentKind = 0 | 2;
-export declare const segmentKinds: {
-    readonly field: 0;
-    readonly element: 2;
+export interface RelationQueryLogicalPlanInput {
+    canonicalInput: QueryNodeId;
+    effectiveInput: QueryNodeId;
+    bypasses: RelationQueryLogicalBypass[];
+}
+export type RelationQueryExplainRequirementInputKind = 'Field' | 'ObservationIdentity' | 'SourceSet' | 'Relationship' | 'Parameter' | 'Capability';
+export declare const relationQueryExplainRequirementInputKinds: {
+    readonly field: "Field";
+    readonly observationIdentity: "ObservationIdentity";
+    readonly sourceSet: "SourceSet";
+    readonly relationship: "Relationship";
+    readonly parameter: "Parameter";
+    readonly capability: "Capability";
 };
-export declare const segmentKindLabels: Record<SegmentKind, string>;
-export type FieldPresence = 0 | 1;
-export declare const fieldPresences: {
-    readonly required: 0;
-    readonly optional: 1;
+export declare const relationQueryExplainRequirementInputKindLabels: Record<RelationQueryExplainRequirementInputKind, string>;
+export interface RelationQueryNativeCompilationDecisionReference {
+    requirement: RelationQueryRealizationRequirementId;
+    kind: CapabilityRealizationKind;
+    capabilityEvidence: RelationQueryTargetCapabilityEvidenceId[];
+    compositionRules: RelationQueryCompositionRuleId[];
+    override?: RelationQueryRealizationOverrideId | null;
+    operatingBoundaries: RelationQueryOperatingBoundaryId[];
+    preservedGuarantees: RelationQueryGuaranteeCapabilityKind[];
+}
+export type RelationQueryRealizationTraceStepKind = 'Structural' | 'ExpressionSite' | 'AggregateOperation' | 'Terminal';
+export declare const relationQueryRealizationTraceStepKinds: {
+    readonly structural: "Structural";
+    readonly expressionSite: "ExpressionSite";
+    readonly aggregateOperation: "AggregateOperation";
+    readonly terminal: "Terminal";
 };
-export declare const fieldPresenceLabels: Record<FieldPresence, string>;
-export interface AnnotationKey {
-    Value: string;
+export declare const relationQueryRealizationTraceStepKindLabels: Record<RelationQueryRealizationTraceStepKind, string>;
+export type RelationQueryExpressionSiteKind = 'FilterPredicate' | 'JoinPredicate' | 'ExpandCollection' | 'ProjectionAssignmentValue' | 'DistinctKey' | 'AggregateGroupingKey' | 'AggregateAssignmentValue' | 'AggregateAssignmentFilter' | 'OrderKey' | 'KeysetBoundary' | 'RelationOutputKey' | 'RelationInvariant' | 'TemporalJoinCorrelation' | 'TemporalJoinPoint' | 'TemporalJoinIntervalLowerBound' | 'TemporalJoinIntervalUpperBound';
+export declare const relationQueryExpressionSiteKinds: {
+    readonly filterPredicate: "FilterPredicate";
+    readonly joinPredicate: "JoinPredicate";
+    readonly expandCollection: "ExpandCollection";
+    readonly projectionAssignmentValue: "ProjectionAssignmentValue";
+    readonly distinctKey: "DistinctKey";
+    readonly aggregateGroupingKey: "AggregateGroupingKey";
+    readonly aggregateAssignmentValue: "AggregateAssignmentValue";
+    readonly aggregateAssignmentFilter: "AggregateAssignmentFilter";
+    readonly orderKey: "OrderKey";
+    readonly keysetBoundary: "KeysetBoundary";
+    readonly relationOutputKey: "RelationOutputKey";
+    readonly relationInvariant: "RelationInvariant";
+    readonly temporalJoinCorrelation: "TemporalJoinCorrelation";
+    readonly temporalJoinPoint: "TemporalJoinPoint";
+    readonly temporalJoinIntervalLowerBound: "TemporalJoinIntervalLowerBound";
+    readonly temporalJoinIntervalUpperBound: "TemporalJoinIntervalUpperBound";
+};
+export declare const relationQueryExpressionSiteKindLabels: Record<RelationQueryExpressionSiteKind, string>;
+export type ExprSiteId = string;
+export interface TemporalInterval {
+    lower: TemporalIntervalBound;
+    upper: TemporalIntervalBound;
 }
-export interface AnnotationValue {
-    Value?: unknown | null;
+export type QuerySortDirection = 'Ascending' | 'Descending';
+export declare const querySortDirections: {
+    readonly ascending: "Ascending";
+    readonly descending: "Descending";
+};
+export declare const querySortDirectionLabels: Record<QuerySortDirection, string>;
+export type QueryNullPlacement = 'First' | 'Last';
+export declare const queryNullPlacements: {
+    readonly first: "First";
+    readonly last: "Last";
+};
+export declare const queryNullPlacementLabels: Record<QueryNullPlacement, string>;
+export type RelationDraftUnresolvedReason = 'NoCandidate' | 'IncompatibleType' | 'UnsafeCardinality' | 'UnsafePresence' | 'UnsafeNullability' | 'ConversionRequired' | 'UnsupportedStructure' | 'UnsupportedTransformation' | 'MultipleCandidates';
+export declare const relationDraftUnresolvedReasons: {
+    readonly noCandidate: "NoCandidate";
+    readonly incompatibleType: "IncompatibleType";
+    readonly unsafeCardinality: "UnsafeCardinality";
+    readonly unsafePresence: "UnsafePresence";
+    readonly unsafeNullability: "UnsafeNullability";
+    readonly conversionRequired: "ConversionRequired";
+    readonly unsupportedStructure: "UnsupportedStructure";
+    readonly unsupportedTransformation: "UnsupportedTransformation";
+    readonly multipleCandidates: "MultipleCandidates";
+};
+export declare const relationDraftUnresolvedReasonLabels: Record<RelationDraftUnresolvedReason, string>;
+export type FieldCardinality = 'Single' | 'Many';
+export declare const fieldCardinalities: {
+    readonly single: "Single";
+    readonly many: "Many";
+};
+export declare const fieldCardinalityLabels: Record<FieldCardinality, string>;
+export type FieldNullability = 'NonNullable' | 'Nullable';
+export declare const fieldNullabilities: {
+    readonly nonNullable: "NonNullable";
+    readonly nullable: "Nullable";
+};
+export declare const fieldNullabilityLabels: Record<FieldNullability, string>;
+export interface RelationQueryLogicalBypass {
+    kind: RelationQueryLogicalBypassKind;
+    node: QueryNodeId;
+    relationship: RelationshipDefinition;
+    direction: RelationshipTraversalDirection;
+    cardinality: RelationshipTraversalCardinality;
+    from: ValueBindingId;
+    result: ValueBindingId;
+}
+export type CapabilityRealizationKind = 'Native' | 'Composed' | 'Constrained' | 'Override' | 'Unavailable' | 'Unknown';
+export declare const capabilityRealizationKinds: {
+    readonly native: "Native";
+    readonly composed: "Composed";
+    readonly constrained: "Constrained";
+    readonly override: "Override";
+    readonly unavailable: "Unavailable";
+    readonly unknown: "Unknown";
+};
+export declare const capabilityRealizationKindLabels: Record<CapabilityRealizationKind, string>;
+export type TemporalIntervalBound = {
+    readonly $temporalBound: 'unbounded';
+} & UnboundedTemporalIntervalBound | {
+    readonly $temporalBound: 'expression';
+} & ExpressionTemporalIntervalBound;
+export type UnboundedTemporalIntervalBound = Record<never, never>;
+export interface ExpressionTemporalIntervalBound {
+    value: Expr;
+    inclusion: TemporalBoundaryInclusion;
+    nullBehavior: TemporalNullBoundBehavior;
 }
+export type RelationQueryLogicalBypassKind = 'OptionalAtMostOneLeftRelationshipTraversal';
+export declare const relationQueryLogicalBypassKinds: {
+    readonly optionalAtMostOneLeftRelationshipTraversal: "OptionalAtMostOneLeftRelationshipTraversal";
+};
+export declare const relationQueryLogicalBypassKindLabels: Record<RelationQueryLogicalBypassKind, string>;
+export type RelationshipTraversalCardinality = 'AtMostOne' | 'Many';
+export declare const relationshipTraversalCardinalities: {
+    readonly atMostOne: "AtMostOne";
+    readonly many: "Many";
+};
+export declare const relationshipTraversalCardinalityLabels: Record<RelationshipTraversalCardinality, string>;
+export type TemporalBoundaryInclusion = 'Inclusive' | 'Exclusive';
+export declare const temporalBoundaryInclusions: {
+    readonly inclusive: "Inclusive";
+    readonly exclusive: "Exclusive";
+};
+export declare const temporalBoundaryInclusionLabels: Record<TemporalBoundaryInclusion, string>;
+export type TemporalNullBoundBehavior = 'Invalid' | 'Unbounded';
+export declare const temporalNullBoundBehaviors: {
+    readonly invalid: "Invalid";
+    readonly unbounded: "Unbounded";
+};
+export declare const temporalNullBoundBehaviorLabels: Record<TemporalNullBoundBehavior, string>;
 export interface QualifiedShapeId {
-    GraphId: GraphId;
-    ShapeId: ShapeId;
+    graphId: GraphId;
+    shapeId: ShapeId;
 }
-export interface RelationDefinition {
-    Id: RelationId;
-    Name: RelationName;
-    Sources: RelationSource[];
-    Joins: JoinDefinition[];
-    Filter?: Expr | null;
-    BaseRowShapeId?: ShapeId | null;
-    Mappings: MappingDefinition[];
-    Materialization?: MaterializationSpec | null;
-    Metadata: RelationMetadata;
-    Invariants: InvariantDefinition[];
+export interface RelationQueryExplainArtifact {
+    schemaVersion: string;
+    stages: RelationQueryExplainStage[];
+    capabilitySummary?: RelationQueryCapabilitySummary | null;
+    diagnostics: RelationQueryExplainDiagnostic[];
+    fingerprint: RelationQueryExplainFingerprint;
+}
+export interface CompiledRelationQueryPhysicalPlan {
+    schemaVersion: string;
+    plan: RelationQueryCompiledPlanReference;
+    realization: RelationQueryRealizationFingerprint;
+    placement: RelationQuerySourcePlacement;
+    policy: RelationQueryPhysicalPlanningPolicy;
+    stages: RelationQueryPhysicalStage[];
+    evaluationOrder: RelationQueryPhysicalStageId[];
+    terminal: RelationQueryPhysicalStageId;
+    diagnostics: RelationQueryPhysicalPlanningDiagnostic[];
+    fingerprint: RelationQueryPhysicalPlanFingerprint;
+}
+export interface RelationQuerySourcePlacement {
+    schemaVersion: string;
+    plan: RelationQueryCompiledPlanReference;
+    conventionSetVersion: string;
+    sourceInstances: RelationQuerySourceInstance[];
+    bindings: RelationQuerySourcePlacementBinding[];
+    configurationDecisions: EffectiveConfigurationDecision[];
+    fingerprint: RelationQuerySourcePlacementFingerprint;
+}
+export interface RelationQueryBoundRealizationReport {
+    profileFeasibility: RelationQueryRealizationReport;
+    placement: RelationQuerySourcePlacementFingerprint;
+    branches: RelationQueryNativeResultBranchId[];
+    evidence: RelationQueryContextualEvidenceProjection;
+    diagnostics: RelationQueryRealizationDiagnostic[];
+    status: RelationQueryRealizationStatus;
+    fingerprint: RelationQueryBoundRealizationFingerprint;
+}
+export interface RelationQueryRealizationReport {
+    plan: RelationQueryCompiledPlanReference;
+    targetProfile: RelationQueryTargetCapabilityProfile;
+    policy: RelationQueryRealizationPolicy;
+    observability: RelationQueryResultObservability;
+    requirements: RelationQueryRealizationRequirement[];
+    decisions: RelationQueryRealizationDecision[];
+    diagnostics: RelationQueryRealizationDiagnostic[];
+    status: RelationQueryRealizationStatus;
+    fingerprint: RelationQueryRealizationFingerprint;
+}
+export interface RelationQueryTargetCapabilityProfile {
+    target: RelationQueryTargetId;
+    id: RelationQueryTargetProfileId;
+    supportedDefinitionSchemaVersions: string[];
+    supportedCompilerProfiles: string[];
+    capabilities: RelationQueryTargetCapabilityEvidence[];
+    operatingBoundaries: RelationQueryOperatingBoundary[];
+    description?: string | null;
+}
+export interface RelationDraftDocument {
+    schemaVersion: string;
+    draft: RelationDraft;
+    draftFingerprint: RelationDraftFingerprint;
+    metadata: RelationDraftDocumentMetadata;
+}
+export interface RelationQueryDocument {
+    schemaVersion: string;
+    definition: RelationQueryDefinition;
+    definitionFingerprint: RelationQueryDefinitionFingerprint;
+    metadata: RelationQueryDocumentMetadata;
+}
+export interface RelationshipCatalogDocument {
+    schemaVersion: string;
+    catalog: RelationshipCatalog;
+    catalogFingerprint: RelationshipCatalogFingerprint;
+    metadata: RelationshipCatalogDocumentMetadata;
 }
 //# sourceMappingURL=relations.shapes.generated.d.ts.map