Module: series - Bijection

Classes

Interfaces

References

Type Aliases

ReadonlyAccessField

Ƭ ReadonlyAccessField: Object Not exported: an exported type refers to it.

Type declaration

Name	Type
`create`	`false`
`update`	`false`
`fields?`	`Record`<`string`, `ReadonlyAccessField`>
`items?`	`ReadonlyAccessField`

CheckedAccessBinding

Ƭ CheckedAccessBinding<B, Permission, Field, Document, SourceOwned>: B & { [K in Exclude<keyof B, keyof AccessResourceBinding<Field, Permission, Document, AccessDefinitionInput, string, SourceOwned>>]?: never } & B extends { fields: infer Fields } ? { fields: { [K in keyof Fields]: K extends Field ? CheckedField<Fields[K], K extends keyof Document ? Document[K] : unknown, SourceOwned> : never } } : unknown & B extends { document: infer DocumentProtection } ? { document: CheckedProtection<DocumentProtection, "read" | SourceOwned extends true ? never : "create" | "delete"> } : unknown & B extends { metadata: infer Metadata } ? { metadata: CheckedProtection<Metadata, "_creationTime"> } : unknown Not exported: an exported type refers to it.

Type parameters

Name	Type
`B`	`B`
`Permission`	extends `string`
`Field`	extends `string` = `string`
`Document`	`Record`<`Field`, `unknown`>
`SourceOwned`	extends `boolean` = `false`

Options

Ƭ Options: Object Not exported: an exported type refers to it.

Type declaration

Name	Type
`checkpoint`	`string`
`replay?`	`"deterministic"`
`context?`	`ProgramContextReads`

FieldsOfKind

Ƭ FieldsOfKind<S, Kind>: { [K in keyof S]: S[K][“isOptional”] extends “required” ? S[K][“kind”] extends Kind ? K : never : never }[keyof S] & string Not exported: an exported type refers to it.

Type parameters

Name	Type
`S`	extends `Fields`
`Kind`	extends `GenericValidator`[`"kind"`]

LiveMediaOptions

Ƭ LiveMediaOptions: Object

Type declaration

Name	Type
`format`	`"mulaw8000"` \| `"pcm16000"` \| `"pcm24000"`
`maxBufferedMs`	`number`
`overflow`	`"close"` \| `"report_gap"`

LiveMediaTicket

Ƭ LiveMediaTicket: Object

Type declaration

Name	Type
`key`	`string`
`digest`	`string`
`sequence`	`number`

LiveMediaLease

Ƭ LiveMediaLease: Object

Type declaration

Name	Type
`id`	`string`
`epoch`	`number`
`options`	`LiveMediaOptions`

LiveMediaStatus

Ƭ LiveMediaStatus: Object

Type declaration

Name	Type	Description
`received`	`number`	-
`forwarded`	`number`	A transport cursor, never proof that the peer consumed audio.
`droppedFrames`	`number`	-
`droppedBytes`	`number`	-
`bufferedBytes`	`number`	-
`bufferedUs`	`number`	-
`gapAfter`	`number` \| `null`	-

Interval

Ƭ Interval: Object Not exported: an exported type refers to it.

Type declaration

Name	Type
`from`	`bigint`
`to`	`bigint`

ModelSeriesOutcome

Ƭ ModelSeriesOutcome: { status: "ready" ; source: SeriesInputValue } | { status: "pending" ; request: string } | { status: "unavailable" ; reason: string }

ModelSeriesInput

Ƭ ModelSeriesInput: Object

Type declaration

Name	Type	Description
`selection`	`ModelSeries` \| { `source`: `SeriesInputValue` ; `series_id`: `string` }	-
`interval`	`Interval`	Arbitrary models depend on each declared input in full.

ModelSeriesArguments

Ƭ ModelSeriesArguments: Object

Type declaration

Name	Type
`inputs`	`Record`<`string`, { `source`: `SeriesInputValue` ; `series`: `string` ; `interval`: `Interval` }>
`seriesIds`	`string`[]
`from`	`bigint`
`to`	`bigint`
`requestId`	`string`

Stage

Ƭ Stage: Object Not exported: an exported type refers to it.

Type declaration

Name	Type
`action`	`FunctionReference`<`"action"`, `any`, `any`, `ModelSeriesOutcome`>
`args`	`Record`<`string`, `Value`>
`inputs`	`Record`<`string`, `ModelSeriesInput`>
`output`	{ `series`: `string` ; `schema`: `SeriesOutputSchema` ; `interval`: `Interval` }
`output.series`	`string`
`output.schema`	`SeriesOutputSchema`
`output.interval`	`Interval`

SourceRef

Ƭ SourceRef: Object One explicitly opened lifetime of an application source. Admission binds one; a closed generation never reopens.

Type declaration

Name	Type
`source_id`	`string`
`generation`	`bigint`

SeriesUploadOccurrence

Ƭ SeriesUploadOccurrence: Object Not exported: an exported type refers to it.

Type declaration

Name	Type
`series_id`	`string`
`source`	`SourceRef`
`event_id`	`string`
`time`	`bigint`
`until?`	`bigint`

SeriesUploadDestination

Ƭ SeriesUploadDestination: Extract<FileUploadSelection["destination"], { kind: "series" }> Not exported: an exported type refers to it.

SeriesEvent

Ƭ SeriesEvent<Values>: Object One accepted occurrence with its engine metadata. Instants are signed microseconds since the epoch. order is the declared business order that resolves corrections; admission_sequence is the engine’s per-series arrival sequence.

Type parameters

Name	Type
`Values`	extends `Record`<`string`, `Value` \| `undefined`> = `Record`<`string`, `Value`>

Type declaration

Name	Type	Description
`fact_id`	`string`	-
`logical_extent`	`LogicalExtent` \| `null`	-
`clock_evidence`	`ClockEvidence`	-
`series_id`	`string`	-
`source`	`SourceRef`	-
`event_id`	`string`	-
`event_key`	`string`	The engine-issued, fully scoped identity of the occurrence.
`time`	`bigint`	-
`order`	`bigint`	-
`received_at`	`bigint`	-
`admission_sequence`	`bigint`	-
`is_late`	`boolean`	-
`retraction?`	`SeriesRetraction`	-
`values`	`Values`	-

ResolvedValues

Ƭ ResolvedValues<Values>: { [K in keyof Values]: Values[K] | null } Not exported: an exported type refers to it.

Type parameters

Name
`Values`

SeriesSample

Ƭ SeriesSample<Values>: Object The resolved representative of one instant. Retraction preserves its occurrence identity and projects invalidated values to null.

Type parameters

Name	Type
`Values`	extends `Record`<`string`, `Value` \| `undefined`> = `Record`<`string`, `Value`>

Type declaration

Name	Type
`event`	`SeriesEvent`<`ResolvedValues`<`Values`>>
`accepted_event_count`	`bigint`
`retraction?`	`SeriesRetraction`

SeriesCoverage

Ƭ SeriesCoverage: Object What a read evaluated: the requested half-open range, and where the retained population begins within it. An empty answer proves nothing about events a source never delivered.

Type declaration

Name	Type	Description
`evidence`	`PopulationEvidence`	Retained-population examination and settlement evidence are independent. Signal support remains on the signal answer; neither establishes freshness.
`from`	`bigint`	-
`to`	`bigint`	-
`visible_from`	`bigint`	-
`is_complete`	`boolean`	Completeness of this answer’s evaluated population, independent of execution state.
`basis_id?`	`string`	Analyses only: the identity of the selected population. Unlike the revision `basis`, equal populations share it across transactions; it grants no authority and asserts no freshness.
`publication?`	{ `required_micros`: `bigint` ; `available_micros`: `bigint` ; `examined_micros`: `bigint` ; `is_complete`: `boolean` ; `is_final`: `boolean` }	Assessed for complete aggregate answers over a window-published series. A page alone makes no whole-range examination claim. `required_micros` is the input span the answer depends on: an expression’s includes its shift and preceding context and is summed over every series it reads, so unexamined context of any read series leaves it incomplete.
`publication.required_micros`	`bigint`	-
`publication.available_micros`	`bigint`	-
`publication.examined_micros`	`bigint`	-
`publication.is_complete`	`boolean`	-
`publication.is_final`	`boolean`	-

SeriesPage

Ƭ SeriesPage<Item>: Object One bounded step of a traversal. It may hold fewer than limit items, even none, with a cursor that represents real progress; a null cursor means the traversal finished for the visible population.

Type parameters

Name
`Item`

Type declaration

Name	Type	Description
`scope?`	`string`	Raw table reads expose the native table incarnation independently of the selected series key, page basis and source privacy generation. Derived population pages need not have a single native table scope.
`execution?`	`SeriesExecutionStats`	-
`items`	`Item`[]	-
`cursor`	`string` \| `null`	-
`basis`	`string`	The read basis a continuation keeps.
`coverage`	`SeriesCoverage`	-

SeriesInput

Ƭ SeriesInput<Values>: Pick<SeriesEvent<Values>, "series_id" | "event_id" | "time" | "order" | "values">

Type parameters

Name	Type
`Values`	extends `Record`<`string`, `Value` \| `undefined`> = `Record`<`string`, `Value`>

SeriesReceipt

Ƭ SeriesReceipt: { kind: "accepted" ; event_key: string ; admission_sequence: bigint ; is_late: boolean } | { kind: "duplicate" ; event_key: string } | { kind: "refused" ; reason: "invalid" | "identity_conflict" | "order_conflict" | "expired" | "erased" | "source_closed" }

SeriesAppendReceipt

Ƭ SeriesAppendReceipt<Table>: { kind: "accepted" ; observation: SeriesObservationRef<Table> ; admissionSequence: bigint ; isLate: boolean } | { kind: "duplicate" ; observation: SeriesObservationRef<Table> } | Extract<SeriesReceipt, { kind: "refused" }> Application append returns its exact correction/retraction locator.

Type parameters

Name	Type
`Table`	extends `string`

SeriesMeasureResult

Ƭ SeriesMeasureResult: { kind: "empty" } | { kind: "int64" ; value: bigint } | { kind: "float64" ; value: number } | { kind: "decimal" ; value: string ; scale: number } Counts, sums, extrema and differences of int64 and decimal values are exact and never silently convert to float; means, integrals and every continuous result are deterministic binary64. An exact result outside int64 or Decimal128 refuses the answer.

SeriesMeasureSummary

Ƭ SeriesMeasureSummary: Object Aggregates of one measure over resolved samples; counts, sums and extrema of int64 and decimal values are exact.

Type declaration

Name	Type
`kind`	{ `kind`: `"int64"` \| `"float64"` } \| { `kind`: `"decimal"` ; `scale`: `number` }
`count`	`bigint`
`missing_count`	`bigint`
`null_count`	`bigint`
`min`	`number` \| `bigint` \| `string` \| `null`
`max`	`number` \| `bigint` \| `string` \| `null`
`sum`	`SeriesMeasureResult`
`mean`	`SeriesMeasureResult`

SeriesSummary

Ƭ SeriesSummary: Object

Type declaration

Name	Type
`basis`	`string`
`coverage`	`SeriesCoverage`
`resolved_sample_count`	`bigint`
`measures`	`Record`<`string`, `SeriesMeasureSummary`>

SeriesRange

Ƭ SeriesRange: Object A half-open event-time range [from, to) of one series.

Type declaration

Name	Type
`series_id`	`string`
`from`	`bigint`
`to`	`bigint`

SeriesWindowUnit

SeriesWindows

Ƭ SeriesWindows: Object

Type declaration

Name	Type
`measure`	`string`
`basis`	`string`
`coverage`	`SeriesCoverage`
`window`	`SeriesWindowUnit`
`calendar`	`CalendarWindow`
`windows`	{ `from`: `bigint` ; `to`: `bigint` ; `is_excluded`: `boolean` ; `summary`: `Omit`<`SeriesSummary`, `"basis"` \| `"coverage"`> }[]

SeriesChart

Ƭ SeriesChart: Object Buckets share one width from a fixed ladder, aligned to UTC multiples of it and clipped to the range; there are at most max_points / 4. Extrema retain their original times. Never connect a bucket with is_gap_present or is_excluded.

Type declaration

Name	Type
`measure`	`string`
`interpretation`	{ `kind`: `"samples"` } \| { `kind`: `"signal"` ; `interpolation`: `"previous"` \| `"linear"` \| `"interval"` ; `max_gap`: `bigint` }
`max_points`	`number`
`basis`	`string`
`coverage`	`SeriesCoverage`
`is_reduced`	`boolean`
`buckets`	{ `from`: `bigint` ; `to`: `bigint` ; `resolved_sample_count`: `bigint` ; `missing_count`: `bigint` ; `null_count`: `bigint` ; `is_excluded`: `boolean` ; `is_gap_present`: `boolean` ; `support_from?`: `bigint` \| `null` ; `support_to?`: `bigint` \| `null` ; `points`: { `time`: `bigint` ; `value`: `number` \| `bigint` \| `string` \| `SeriesMeasureResult` }[] }[]

SeriesSignalSummary

Ƭ SeriesSignalSummary: Object Integral units are measure × seconds; covered_mean excludes uncovered duration. Durations are whole microseconds.

Type declaration

Name	Type
`measure`	`string`
`interpolation`	`"previous"` \| `"linear"` \| `"interval"`
`max_gap`	`bigint`
`basis`	`string`
`coverage`	`SeriesCoverage`
`covered_micros`	`bigint`
`uncovered_micros`	`bigint`
`integral`	`SeriesMeasureResult`
`covered_mean`	`SeriesMeasureResult`
`interval_mean`	`SeriesMeasureResult` \| { `kind`: `"incomplete"` }

SeriesSignalPolicy

Ƭ SeriesSignalPolicy: { method: "previous" | "linear" ; maxGap: Duration | string } | { method: "interval" ; maxGap?: never } A signal interpolates bounded gaps or uses each sample’s declared interval.

SeriesInterval

Ƭ SeriesInterval: Object A half-open event-time interval [from, to) in microseconds.

Type declaration

Name	Type
`from`	`Instant`
`to`	`Instant`

SeriesExecutionStats

Ƭ SeriesExecutionStats: Object Physical work counters; allocation charges are not process memory.

Type declaration

Name	Type
`stoppedBy`	`"complete"` \| `"page_limit"` \| `"work_limit"`
`headersRead`	`number`
`blocksDecoded`	`number`
`blocksPruned`	`number`
`historicalBlocksFetched`	`number`
`encodedBytesFetched`	`number`
`decodedAllocationChargeBytes`	`number`
`samplesResolved`	`number`
`samplesMatched`	`number`

SeriesPageOptions

Ƭ SeriesPageOptions: Object

Type declaration

Name	Type
`diagnostics?`	`"execution"`
`limit?`	`number`
`cursor?`	`string` \| `null`
`direction?`	`"asc"` \| `"desc"`

SeriesAnalysisKind

SeriesSettlementRequirement

Ƭ SeriesSettlementRequirement: { kind: "source" } | { kind: "publisher" } | { kind: "policy" ; maxLateness: bigint | string }

SeriesReadRequirements

Ƭ SeriesReadRequirements: Object

Type declaration

Name	Type	Description
`coverage?`	`"complete"`	-
`support?`	`"complete"`	-
`settlement?`	`SeriesSettlementRequirement`	-
`maxObservationAge?`	`string`	Native source observation evidence; event/ingestion timestamps do not qualify.

SeriesRequirementFailure

Ƭ SeriesRequirementFailure: Object

Type declaration

Name	Type
`kind`	`"series_requirement"`
`requirement`	`"coverage"` \| `"support"` \| `"settlement"` \| `"maxObservationAge"` \| `"selection"`
`reason`	`"pending"` \| `"unsupported"` \| `"excluded"` \| `"stale"`

SeriesScopeProblem

Ƭ SeriesScopeProblem: Object A scope has no trustworthy resolved sample population.

Type declaration

Name	Type
`kind`	`"series_unavailable"`
`reason`	{ `kind`: `"conflict"` ; `series`: `string` ; `time`: `bigint` } \| { `kind`: `"repairing"` }

SeriesProblem

Ƭ SeriesProblem: SeriesFailure | SeriesScopeProblem Closed problem data shared by temporal read outcomes and thrown errors. Scope conflicts and repairs are availability problems; invalid arguments and certified-content integrity failures still throw.

SeriesRead

Ƭ SeriesRead<Data, Evidence, Execution>: { kind: "available" ; execution?: Execution | null } & SeriesEvaluation<Data, Evidence> | { kind: "requiresRun" ; problem: Extract<SeriesFailure, { kind: "series_work_required" } | { kind: "series_history" }> | Extract<SeriesFailure, { kind: "series_operator_unavailable" }> & { operator: "customer_placement" } } | { kind: "unavailable" ; problem: Extract<SeriesFailure, { kind: "series_history" } | { kind: "series_conflict" }> | SeriesScopeProblem } What one bounded read establishes. available means evaluation finished; coverage, support, source completeness and freshness remain independent. requiresRun records no work: start explicitly from a mutation. Every unanswered read carries its closed problem.

Type parameters

Name	Type
`Data`	`Data`
`Evidence`	`SeriesCoverageEvidence`
`Execution`	`SeriesExecutionStats`

SeriesReadFor

Ƭ SeriesReadFor<Result, Execution>: SeriesRead<SeriesData<Result>, SeriesEvidence<Result>, Execution> Infer the payload and evidence from a selected native operator.

Type parameters

Name	Type
`Result`	`Result`
`Execution`	`SeriesExecutionStats`

SeriesChangeArrival

Ƭ SeriesChangeArrival: Object Operational stamps of watched changes, in unix microseconds. They are not event time, source position or source order.

Type declaration

Name	Type	Description
`observed_at`	`bigint` \| `null`	The greatest acquisition instant of the occurrences these changes admitted; null when only corrections, selections or retractions changed.
`admitted_at`	`bigint`	The engine clock of the newest included revision’s transaction, which precedes its commit.
`earliest_admitted_at`	`bigint`	The engine clock of the oldest included revision’s transaction.

SeriesExplainOptions

Ƭ SeriesExplainOptions: SeriesInputReadOptions & { physical?: boolean ; executionProfiles?: readonly ("nativeDirect" | "nativeRetained")[] } Native temporal planning facts. Contract integer parameters use exact decimal text; time ranges and support durations are bigint microseconds.

SeriesInputReadOptions

Ƭ SeriesInputReadOptions: Object Reuse an existing native analysis’s independently held original inputs. This read context changes no question or answer identity. Current source authority is checked on every read; expired or cancelled custody is refused. Use it for Dataset-backed mixed inputs whose owners require delivery claims.

Type declaration

Name	Type
`inputAnalysis?`	`SeriesAnalysisId`<`SeriesAnalysisKind`, `unknown`>

SeriesPlanSummary

Ƭ SeriesPlanSummary: Object Application-level planning facts. Eligibility still requires current access, resident inputs and runtime budgets; it does not imply deployed qualification.

Type declaration

Name	Type
`question`	{ `collection`: `string` \| `null` ; `series`: `string`[] ; `range`: { `from`: `bigint` \| `null` ; `to`: `bigint` \| `null` } ; `operation`: `string` }
`question.collection`	`string` \| `null`
`question.series`	`string`[]
`question.range`	{ `from`: `bigint` \| `null` ; `to`: `bigint` \| `null` }
`question.range.from`	`bigint` \| `null`
`question.range.to`	`bigint` \| `null`
`question.operation`	`string`
`execution`	{ `direct`: { `kind`: `"eligible"` \| `"unavailable"` ; `code`: `string` ; `message`: `string` } ; `retained`: { `kind`: `"eligible"` \| `"unavailable"` ; `code`: `string` ; `message`: `string` } }
`execution.direct`	{ `kind`: `"eligible"` \| `"unavailable"` ; `code`: `string` ; `message`: `string` }
`execution.direct.kind`	`"eligible"` \| `"unavailable"`
`execution.direct.code`	`string`
`execution.direct.message`	`string`
`execution.retained`	{ `kind`: `"eligible"` \| `"unavailable"` ; `code`: `string` ; `message`: `string` }
`execution.retained.kind`	`"eligible"` \| `"unavailable"`
`execution.retained.code`	`string`
`execution.retained.message`	`string`

SeriesPlanExplanation

Ƭ SeriesPlanExplanation: SeriesPlanSummary & { plan: string ; capabilities: ExecutionCapabilities ; requirements?: SeriesReadRequirements | null ; physical?: { strategy: string ; predicate: SeriesExpressionNode | null ; residual: string ; block_pruning: string ; estimates: { headers: { lower: number ; upper: number | null ; isExhaustive: boolean } } } ; evidence: { population: "retained_inputs_only" ; settlement: "declared_source_receipts_and_publication_claims" ; signal_support: "collector_dependent" ; placement_affects_identity: false } ; definition_digest: string ; question_id: string | null ; property_revision: string | null ; basis_id: string | null ; input_basis?: ComputationBasis ; capture?: SeriesPropertyCapturePlan ; population: "resolved" ; range: SeriesInterval ; inputs: { series_id: string ; measures: string[] ; from: bigint ; to: bigint ; settlement?: PopulationEvidence["settlement"] } & { kind?: "native" ; table: string } | { kind: "virtual" ; table: string ; version: string | null } | { kind: "retained" ; table: null ; result: SeriesInputValue["result"] ; rows: SeriesInputValue["rows"] ; coverage: SeriesInputValue["coverage"] ; seal: SeriesOutputManifest["seal"] }[] ; operators: { id: string ; inputs: string[] ; operator: SeriesExpressionNode["op"] | "trajectory" | "fleet_trajectories" | "fleet_encounters" ; ordering: "any" | "ascending" ; context: Record<string, string> ; state: Record<string, string> ; arithmetic: "read" | "exact" | "binary64" | "accumulation" | "logic" ; partitioning: "instants" | "sequential" | "together" }[] ; context_micros: bigint ; lookahead_micros: bigint ; origin: bigint | null ; storage?: { kind: "not_configured" } | { kind: "configured" ; target_lag_micros: bigint ; next_maintenance_at: bigint | null ; pending_ranges: SeriesInterval[] ; is_input_change_pending: boolean ; maintenance: "pending" | "scheduled" | "blocked" ; error: SeriesAnalysisFailure | null ; read_eligibility: "requires_current_input_proof" } ; execution?: { strategy: "captured_native_merge" ; inputs: number ; checkpoint: "per_source_cursor" } ; is_durable_supported: boolean }

SeriesFields

Ƭ SeriesFields<Values>: readonly Extract<keyof Values, string>[] | undefined A projection: omitted, the full payload; a literal list selects exact fields; a dynamic list may omit any payload property.

Type parameters

Name	Type
`Values`	extends `Record`<`string`, `Value` \| `undefined`>

SeriesTrajectoryEndpoint

Ƭ SeriesTrajectoryEndpoint: TrajectoryEndpoint A reported or interpolated endpoint. Only observed endpoints retain the report’s accuracy; interpolation has unknown accuracy.

SeriesTrajectorySegment

Ƭ SeriesTrajectorySegment: TrajectorySegment Both supporting accepted occurrences are identified within the answer’s series and basis, even when outside its requested interval.

SeriesTrajectoryFix

Ƭ SeriesTrajectoryFix: TrajectoryFix A resolved report inside the requested half-open interval. Includes lone reports and reports separated by unknown positions or excessive gaps. Boundary context outside the interval is only segment support.

SeriesTrajectoryInterpolation

Ƭ SeriesTrajectoryInterpolation: "linear_shortest" | "geodesic" How a trajectory moves between consecutive fixes: the native great elliptic arc, or the WGS84 geodesic at constant speed.

SeriesTrajectoryProfile

Ƭ SeriesTrajectoryProfile: "wgs84-2d-great-elliptic-v1" | "wgs84-2d-geodesic-v1" The path model a trajectory answer declares, one per interpolation.

SeriesTrajectory

Ƭ SeriesTrajectory: Object A bounded set of resolved fixes and clipped segments under an explicit path model. Gaps and missing/null positions break the path. Completeness includes the padded support interval; covered duration measures continuity separately. Longitudes crossing the antimeridian must be unwrapped under profile before rendering; endpoints are not a GeoJSON LineString.

Type declaration

Name	Type
`basis`	`string`
`coverage`	`SeriesCoverage`
`support_coverage`	`SeriesCoverage`
`profile`	`SeriesTrajectoryProfile`
`position`	`string`
`max_gap`	`bigint`
`covered_micros`	`bigint`
`uncovered_micros`	`bigint`
`fixes`	`SeriesTrajectoryFix`[]
`segments`	`SeriesTrajectorySegment`[]

SeriesFleetTrajectories

Ƭ SeriesFleetTrajectories: Object Retained paths discovered in one transaction. Regional reads can use a declared native space-time index, with dirty paths refined from current observations. Discovery, decoding and returned paths share fleet-wide bounds; exhaustion refuses the entire result.

Type declaration

Name	Type
`basis`	`string`
`coverage`	`SeriesCoverage`
`support_coverage`	`SeriesCoverage`
`trajectories`	{ `series_id`: `string` ; `trajectory`: `SeriesTrajectory` }[]
`index`	`FleetTrajectories`[`"index"`]

SeriesTrajectoryIndexStatus

Ƭ SeriesTrajectoryIndexStatus: TrajectoryIndexStatus Native index maintenance state. dirty_series is a lower bound when is_truncated=true. A ready index still refines current native observations.

SeriesPositionField

Ƭ SeriesPositionField<Values>: string extends keyof Values ? string : { [Key in Extract<keyof Values, string>]-?: [Exclude<Values[Key], null | undefined>] extends [never] ? never : Exclude<Values[Key], null | undefined> extends Position ? Key : never }[Extract<keyof Values, string>] Declared position payload fields, optionally nullable or absent.

Type parameters

Name	Type
`Values`	extends `Record`<`string`, `Value` \| `undefined`>

SeriesFilteredSelection

Ƭ SeriesFilteredSelection<Values>: Pick<SeriesSelection<Values>, "samples" | "whereSamples" | "summary" | "windows" | "signal"> & { require: (requirements: SeriesReadRequirements) => SeriesFilteredSelection<Values> } A resolved sample population. Signal reconstruction uses only matching samples, under its explicit interpolation and gap policy.

Type parameters

Name	Type
`Values`	extends `Record`<`string`, `Value` \| `undefined`>

SeriesPeriodOptions

Ƭ SeriesPeriodOptions: Object Not exported: an exported type refers to it.

Type declaration

Name	Type
`every`	`bigint` \| `string`
`origin?`	`bigint`
`closed?`	`"start"` \| `"end"`
`label?`	`"start"` \| `"end"`

SeriesResampleOptions

Ƭ SeriesResampleOptions: Object Not exported: an exported type refers to it.

Type declaration

Name	Type
`every`	`bigint` \| `string`
`origin`	`bigint`
`maxGap`	`Duration` \| `string`
`method`	`"previous"` \| `"next"` \| `"nearest"` \| `"linear"`
`boundary`	{ `before`: `"none"` \| `"nearest"` ; `after`: `"none"` \| `"nearest"` }
`boundary.before`	`"none"` \| `"nearest"`
`boundary.after`	`"none"` \| `"nearest"`

SeriesSampledOptions

Ƭ SeriesSampledOptions: Object Numerical evaluation of supported signals at origin + k * every. No between-grid curve or continuous threshold interval is implied. Values are binary64 with pinned software elementary functions. A divisor with absolute value at most zeroTolerance follows domainErrors.

Type declaration

Name	Type
`every`	`bigint` \| `string`
`origin`	`bigint`
`domainErrors`	`"reject"` \| `"absent"`
`zeroTolerance`	`number` \| `bigint` \| `string`

SeriesBins

Ƭ SeriesBins: { lower: number | bigint | string ; upper: number | bigint | string } & { count: number } | { width: number | bigint | string } Not exported: an exported type refers to it.

SeriesRegressionOptions

Ƭ SeriesRegressionOptions: Object Not exported: an exported type refers to it.

Type declaration

Name	Type
`model`	`SeriesFitModel`
`origin`	`bigint`
`per`	`bigint` \| `string`

SeriesSignalRegressionOptions

Ƭ SeriesSignalRegressionOptions: Object Least squares weighted by supported physical time. No observation count or sample degrees of freedom are inferred from a signal.

Type declaration

Name	Type
`weight`	`"time"`
`model`	`Extract`<`SeriesFitModel`, { `kind`: `"polynomial"` }>
`origin`	`bigint`
`per`	`bigint` \| `string`

SeriesScatterOptions

Ƭ SeriesScatterOptions: SeriesResampleOptions & { x: SeriesNumbers ; maxPoints?: number ; fit?: SeriesFitModel ; grid?: { x: SeriesBins ; y: SeriesBins } } Not exported: an exported type refers to it.

SeriesAnalysisFailure

Ƭ SeriesAnalysisFailure: { reason: "cancelled" | "deadline" | "erased" | "retracted" | "expired" | "too_large" | "overflow" | "intervention" | "definition_changed" } | { reason: "bound" ; dimension: Extract<SeriesFailure, { kind: "series_bound" }>["dimension"] } | { reason: "conflict" ; time: bigint ; order: bigint ; admission_sequence: bigint } Why a prepared analysis has no answer.

SeriesAnalysisOptions

Ƭ SeriesAnalysisOptions: { kind: "fleet_encounters" ; position: string ; max_gap: bigint ; series_ids: string[] ; area: Geometry | Box | null ; metric: SeriesEncounterOptions["metric"] ; max_encounters: number } | { kind: "fleet_trajectories" ; position: string ; max_gap: bigint ; series_ids: string[] ; area: Geometry | Box | null } | { kind: "trajectory" ; position: string ; interpolation: SeriesTrajectoryInterpolation ; max_gap: bigint } | { kind: "chart" ; max_points: number } | { kind: "windows" ; every: CalendarWindow } | { kind: "signal" ; interpolation: "previous" | "linear" | "interval" ; max_gap: bigint } | { kind: "signal_windows" ; interpolation: "previous" | "linear" | "interval" ; max_gap: bigint ; every: CalendarWindow } | { kind: "expression" ; output: ExpressionOutput } | { kind: "summary" } | { kind: "population_summary" } | { kind: "signal_chart" ; interpolation: "previous" | "linear" | "interval" ; max_gap: bigint ; max_points: number } Settings retained with a prepared answer.

SeriesAnalysisId

Ƭ SeriesAnalysisId<Kind, Result>: string & { __seriesAnalysisKind: Kind ; __seriesResult: Result } An opaque retained execution handle. It locates work and grants no authority.

Type parameters

Name	Type
`Kind`	extends `SeriesAnalysisKind` = `SeriesAnalysisKind`
`Result`	`never`

SeriesAnalysisResult

Ƭ SeriesAnalysisResult<Kind>: Kind extends "fleet_encounters" ? SeriesFleetEncounters : Kind extends "fleet_trajectories" ? SeriesFleetTrajectories : Kind extends "trajectory" ? SeriesTrajectory : Kind extends "population_summary" ? SeriesSummary : Kind extends "summary" ? SeriesExpressionSummary : Kind extends "signal_windows" ? SeriesSignalWindows : Kind extends "windows" ? SeriesWindows : Kind extends "chart" | "signal_chart" ? SeriesChart : Kind extends "expression" ? SeriesExpressionResult : SeriesSignalSummary Not exported: an exported type refers to it.

Type parameters

Name	Type
`Kind`	extends `SeriesAnalysisKind`

SeriesPagedTrajectoryAnalysis

Ƭ SeriesPagedTrajectoryAnalysis: Omit<PagedTrajectoryAnalysis, "evidence"> & { evidence: SeriesTrajectory } A sealed complete result; individual pages retain this same identity.

SeriesTrajectoryResultPage

Ƭ SeriesTrajectoryResultPage: Omit<TrajectoryResultPage, "state" | "result"> & { evidence: SeriesTrajectory } Each page rechecks current authorization, erasure and retention.

SeriesSourceStatus

Ƭ SeriesSourceStatus: Object A source and the reclamation of its closed generations.

Type declaration

Name	Type
`phase`	`"active"` \| `"retiring"` \| `"retired"` \| `"blocked"`
`generation`	`bigint`
`retry_at`	`bigint` \| `null`
`failure`	`string` \| `null`
`recovery`	`RecoveryState` \| `null`

SeriesMaintenanceStatus

Ƭ SeriesMaintenanceStatus: Object Bounded work on the UTC hour containing the requested time.

Type declaration

Name	Type
`phase`	`"idle"` \| `"pending"` \| `"blocked"`
`hour`	`bigint`
`fragments`	`bigint`
`generation`	`bigint`
`retry_at`	`bigint` \| `null`
`failure`	`string` \| `null`
`recovery`	`RecoveryState` \| `null`

SeriesTable

Ƭ SeriesTable<DataModel>: string extends TableNamesInDataModel<DataModel> ? string : { [Table in TableNamesInDataModel<DataModel>]: DataModel[Table] extends Object ? Table : never }[TableNamesInDataModel<DataModel>] Not exported: an exported type refers to it.

Type parameters

Name	Type
`DataModel`	extends `GenericDataModel`

SourceSeriesTable

Ƭ SourceSeriesTable<DataModel>: { [Table in SeriesTable<DataModel>]: DataModel[Table] extends Object ? never : Table }[SeriesTable<DataModel>] Not exported: an exported type refers to it.

Type parameters

Name	Type
`DataModel`	extends `GenericDataModel`

Payload

Ƭ Payload<DataModel, Table>: string extends TableNamesInDataModel<DataModel> ? Record<string, Value> : DataModel[Table] extends { seriesValues: infer P } ? P extends Record<string, Value | undefined> ? P : never : never Not exported: an exported type refers to it.

Type parameters

Name	Type
`DataModel`	extends `GenericDataModel`
`Table`	extends `SeriesTable`<`DataModel`>

ProjectedPayload

Ƭ ProjectedPayload<Values, Fields>: Fields extends readonly Extract<keyof Values, string>[] ? number extends Fields["length"] ? Partial<Values> : Pick<Values, Fields[number]> : Values Not exported: an exported type refers to it.

Type parameters

Name	Type
`Values`	extends `Record`<`string`, `Value` \| `undefined`>
`Fields`	extends readonly `Extract`<keyof `Values`, `string`>[] \| `undefined`

SeriesKeyedKnowledge

Ƭ SeriesKeyedKnowledge: Object Entity coverage is additional proof beyond uniform population examination.

Type declaration

Name	Type
`projection`	{ `kind`: `"fields"` ; `fields`: readonly `string`[] } \| { `kind`: `"tuple"` ; `field`: `string` }
`regions`	{ `key`: `string` ; `knowledge`: { `examined`: { `from`: `bigint` ; `to`: `bigint` }[] ; `settled`: { `from`: `bigint` ; `to`: `bigint` }[] } }[]

SeriesWindowResult

Ƭ SeriesWindowResult: Object An immutable accepted population, independent of serving selection.

Type declaration

Name	Type	Description
`fingerprint`	`string`	-
`result`	`string`	-
`content`	`string`	-
`from`	`bigint`	-
`to`	`bigint`	-
`first`	`bigint`	-
`last`	`bigint`	-
`through`	`bigint`	Admission position when this result was accepted; selection never rewrites it.
`knowledge`	`ResultRef`<`SeriesWindowKnowledge`, `"dataset"`>	-
`knowledge_rows`	`string`	-
`key_projection`	`SeriesKeyedKnowledge`[`"projection"`] \| `null`	-
`is_final`	`boolean`	-

SeriesWindowKnowledge

Ƭ SeriesWindowKnowledge: { kind: "entity" ; key: string } | { kind: "examined" | "settled" ; key: string | null ; from: { numerator: string ; denominator: string } ; to: { numerator: string ; denominator: string } } Not exported: an exported type refers to it.

SeriesWindowKnowledgePage

Ƭ SeriesWindowKnowledgePage: Object Not exported: an exported type refers to it.

Type declaration

Name	Type
`result`	`string`
`records`	`SeriesWindowKnowledge`[]
`cursor`	`string` \| `null`

SeriesWindowSelection

Ƭ SeriesWindowSelection: Object One visibility decision. Selecting a result never changes its acceptance.

Type declaration

Name	Type
`result`	`string`
`from`	`bigint`
`to`	`bigint`
`sequence`	`bigint`
`through`	`bigint`

SeriesWindowPopulation

Ƭ SeriesWindowPopulation<Values>: Object A complete candidate, including successful empty examination.

Type parameters

Name
`Values`

Type declaration

Name	Type
`series_id`	`string`
`source_id`	`string`
`from`	`bigint`
`to`	`bigint`
`fingerprint`	`string`
`examined`	{ `from`: `bigint` ; `to`: `bigint` }[]
`keyed?`	`SeriesKeyedKnowledge` \| `null`
`is_final`	`boolean`
`events`	{ `fact_id`: `string` ; `logical_extent`: `LogicalExtent` \| `null` ; `time`: `bigint` ; `values`: `Values` ; `clock_evidence`: `ClockEvidence` }[]

SeriesDerivation

Ƭ SeriesDerivation: Object Immutable semantic coordinates; private runs and code have separate custody.

Type declaration

Name	Type
`producer`	`string`
`definition_revision`	`string`
`member`	`string`
`subject`	`string`
`timeline`	`string`

SeriesErasureTarget

Ƭ SeriesErasureTarget: { kind: "series" ; series_id: string } | { kind: "source" ; series_id: string ; source_id: string } | { kind: "event" ; series_id: string ; source: SourceRef ; event_id: string } | { kind: "range" ; series_id: string ; from: bigint ; to: bigint } Native reads observe the declared series policy, including absence. A range target erases every event of the series, from any source, whose time in microseconds is at least from and before to.

SeriesErasureCopy

Ƭ SeriesErasureCopy: { state: "not_applicable" | "complete" } | { state: "working" ; step: "rewrite" | "keys" } | { state: "blocked" ; reason: "retry_required" | "acquisition_custody" | "upload_custody" | "original_membership" | "shared_outputs" | "input_custody" | "backup_custody" | "native_copies" | "broker_custody" } Progress of one copy owner. A locator grants no authority. Native and acquisition copies rewrite their own blocks; the archive appends erase rows to its change log, then verification proves catalog maintenance purged the erased rows.

SeriesErasureStatus

Ƭ SeriesErasureStatus: Object Visibility changes in the requesting commit. Destruction waits for every copy owner.

Type declaration

Name	Type
`request`	`string`
`visibility`	`"excluded"`
`destruction`	`"working"` \| `"blocked"` \| `"complete"`
`copies`	{ `native`: `SeriesErasureCopy` ; `lake`: `"not_applicable"` \| `"pending"` \| `"appended"` \| `"verified"` \| `"overdue"` ; `acquisition`: `SeriesErasureCopy` ; `broker`: `SeriesErasureCopy` ; `files`: `SeriesErasureCopy` }
`copies.native`	`SeriesErasureCopy`
`copies.lake`	`"not_applicable"` \| `"pending"` \| `"appended"` \| `"verified"` \| `"overdue"`
`copies.acquisition`	`SeriesErasureCopy`
`copies.broker`	`SeriesErasureCopy`
`copies.files`	`SeriesErasureCopy`
`destroyed_blocks`	`bigint`
`retry_at`	`bigint` \| `null`
`failure`	`string` \| `null`
`recovery`	`RecoveryState` \| `null`

SeriesRunObservation

Ƭ SeriesRunObservation: SeriesResultFor<SeriesAnalysisResult<SeriesAnalysisKind> | SeriesFleetPage<unknown, Record<string, TemporalScalar>>> Untyped handles recovered from storage may name either a root or a fleet.

SeriesCompositionInput

Ƭ SeriesCompositionInput: { table: string ; series_id: string ; field: string } | { source: SeriesInputValue ; series_id: string } | SeriesRef One primitive native source or authorized object property in a composed question. Its declaration supplies types, units and current authority; this reference grants no access.

SeriesRunOptions

Ƭ SeriesRunOptions: Object Admission and execution policy for a retained temporal question.

Type declaration

Name	Type	Description
`require?`	`SeriesReadRequirements`	Strengthen the original plan’s evidence requirements at admission.
`resultDelivery?`	{ `kind`: `"paged"` ; `pageSize`: `number` ; `maxItems`: `number` }	Native trajectory delivery, bounded separately from evaluator state. pageSize is 128–512, maxItems is 1–100000; retained output is at most 64 MiB.
`resultDelivery.kind`	`"paged"`	-
`resultDelivery.pageSize`	`number`	-
`resultDelivery.maxItems`	`number`	-
`replayFrom?`	`string`	Reuse a valid native interval-kernel prefix owned by a prior prepared analysis. Current authority and source changes are rechecked. Missing, expired or incompatible checkpoints fall back to complete native replay.
`execution?`	{ `policy`: `"native"` ; `deadline?`: `bigint` \| `string` }	The deadline does not change mathematical identity. A relative deadline resolves once during physical admission and stops pending work independently of the retained result’s lifetime. Series expressions run natively. External execution uses a configured function-backed series or temporal boundary on customer compute, through the ordinary Compute and resource owners.
`execution.policy`	`"native"`	-
`execution.deadline?`	`bigint` \| `string`	-
`retention?`	{ `result?`: `bigint` \| `string` ; `reproducibleFor?`: `bigint` \| `string` }	Lifetimes of the retained result, independent of execution. `result` keeps the accepted result readable under current authority (default one hour, at most seven days). `reproducibleFor` keeps the exact selected inputs resident for recomputation, at most the answer lifetime. Once it lapses, or source retention passes a folded input, the answer stays readable and its evidence reports the lapse.
`retention.result?`	`bigint` \| `string`	-
`retention.reproducibleFor?`	`bigint` \| `string`	-

SeriesFilteredPropertySelection

Ƭ SeriesFilteredPropertySelection<Measure, V>: Pick<SeriesPropertySelection<Measure, V>, "samples" | "summary" | "windows" | "whereSamples" | "signal"> & { require: (requirements: SeriesReadRequirements) => SeriesFilteredPropertySelection<Measure, V> } Sample filtering on one authorized primitive property.

Type parameters

Name	Type
`Measure`	extends `string` = `string`
`V`	extends `Value` \| `undefined` = `Value`

SeriesKeyFor

Ƭ SeriesKeyFor<D, T>: D[T] extends { seriesKey: infer Key } ? Key : string | Record<string, string | bigint | boolean> Not exported: an exported type refers to it.

Type parameters

Name	Type
`D`	extends `GenericDataModel`
`T`	extends `SeriesTable`<`D`>

SeriesSignalWindows

Ƭ SeriesSignalWindows: Object Signal summaries per captured calendar window under one temporal policy.

Type declaration

Name	Type
`basis`	`string`
`coverage`	`SeriesCoverage`
`measure`	`string`
`window`	`SeriesWindowUnit`
`calendar`	`CalendarWindow`
`windows`	{ `from`: `bigint` ; `to`: `bigint` ; `summary`: `Omit`<`SeriesSignalSummary`, `"basis"` \| `"measure"`> }[]

SeriesRetraction

Ƭ SeriesRetraction: Readonly<{ request_id: string ; event_key: string ; resolution: string ; time: bigint ; order: bigint ; reason: string ; actor: string ; recorded_at: bigint ; admission_sequence: bigint }> Native auditable quality decision; it grants no source authority.

ExecutionProfileCapability

Ƭ ExecutionProfileCapability: Object Not exported: an exported type refers to it.

Type declaration

Name	Type
`profile`	`"native_direct"` \| `"native_prepared"`
`numerical_contract`	`"exact"` \| `"binary64"`
`status`	`"eligible"` \| `"unsupported_semantics"` \| `"resource_limit"` \| `"binding_unavailable"`
`admission`	{ `state`: `"required"` ; `checks`: (`"current_authority"` \| `"exact_sources"` \| `"resource_limits"` \| `"deadline_and_retention"`)[] }
`admission.state`	`"required"`
`admission.checks`	(`"current_authority"` \| `"exact_sources"` \| `"resource_limits"` \| `"deadline_and_retention"`)[]
`refusals`	{ `node`: `string` \| `null` ; `code`: `string` }[]

ExecutionCapabilities

Ƭ ExecutionCapabilities: Object Not exported: an exported type refers to it.

Type declaration

Name	Type
`profiles`	`ExecutionProfileCapability`[]
`graph_limits`	{ `native_direct`: { `nodes`: `string` ; `depth`: `string` } ; `native_prepared`: { `nodes`: `string` ; `depth`: `string` } ; `required`: { `nodes`: `string` ; `depth`: `string` } }
`graph_limits.native_direct`	{ `nodes`: `string` ; `depth`: `string` }
`graph_limits.native_direct.nodes`	`string`
`graph_limits.native_direct.depth`	`string`
`graph_limits.native_prepared`	{ `nodes`: `string` ; `depth`: `string` }
`graph_limits.native_prepared.nodes`	`string`
`graph_limits.native_prepared.depth`	`string`
`graph_limits.required`	{ `nodes`: `string` ; `depth`: `string` }
`graph_limits.required.nodes`	`string`
`graph_limits.required.depth`	`string`
`scalar_limits`	{ `operator_state_bytes`: `string` ; `result_items`: `string` ; `aligned_instants`: `string` }
`scalar_limits.operator_state_bytes`	`string`
`scalar_limits.result_items`	`string`
`scalar_limits.aligned_instants`	`string`
`prepared_limits`	{ `lifetime_micros`: `string` ; `control_bytes`: `string` ; `inline_checkpoint_bytes`: `string` ; `operator_storage_bytes`: `string` ; `operator_page_bytes`: `string` ; `operator_step_pages`: `string` ; `operator_step_bytes`: `string` ; `operator_operations`: `string` ; `operator_step_operations`: `string` ; `operator_step_observations`: `string` ; `paged_output_items`: `string` ; `paged_output_bytes`: `string` ; `paged_output_kinds`: `"trajectory"`[] ; `operator_paging`: `"native_scalar_without_interval_replay"` }
`prepared_limits.lifetime_micros`	`string`
`prepared_limits.control_bytes`	`string`
`prepared_limits.inline_checkpoint_bytes`	`string`
`prepared_limits.operator_storage_bytes`	`string`
`prepared_limits.operator_page_bytes`	`string`
`prepared_limits.operator_step_pages`	`string`
`prepared_limits.operator_step_bytes`	`string`
`prepared_limits.operator_operations`	`string`
`prepared_limits.operator_step_operations`	`string`
`prepared_limits.operator_step_observations`	`string`
`prepared_limits.paged_output_items`	`string`
`prepared_limits.paged_output_bytes`	`string`
`prepared_limits.paged_output_kinds`	`"trajectory"`[]
`prepared_limits.operator_paging`	`"native_scalar_without_interval_replay"`
`qualification`	{ `state`: `"unknown"` }
`qualification.state`	`"unknown"`

CalendarUnit

WindowUnit

Ƭ WindowUnit: Object Not exported: an exported type refers to it.

Type declaration

Name	Type
`unit`	`CalendarUnit`
`coordinates`	{ `zone`: `string` ; `rules`: `"proleptic_gregorian_monday_v1"` ; `tzdb`: `"iana:2026c/jiff-tzdb:0.1.8"` ; `fold`: `"earlier"` \| `"later"` \| `"reject"` ; `gap`: `"shift_forward"` \| `"reject"` }
`coordinates.zone`	`string`
`coordinates.rules`	`"proleptic_gregorian_monday_v1"`
`coordinates.tzdb`	`"iana:2026c/jiff-tzdb:0.1.8"`
`coordinates.fold`	`"earlier"` \| `"later"` \| `"reject"`
`coordinates.gap`	`"shift_forward"` \| `"reject"`

ExpressionOutput

Ƭ ExpressionOutput: { kind: "states" ; limit: number } | { kind: "intervals" ; min_micros: string } | { kind: "interval_duration" ; min_micros: string } | { kind: "samples" } | { kind: "sampled" ; every: string ; origin: string ; domain_errors: "reject" | "absent" ; zero_tolerance: string } | { kind: "resample" ; every: string ; origin: string ; max_gap: string ; method: "previous" | "next" | "nearest" | "linear" ; boundary: { before: "none" | "nearest" ; after: "none" | "nearest" } } | { kind: "summary" } | { kind: "distribution" ; bins: Bins ; others: unknown[] } | { kind: "regression" ; model: FitModel ; origin: string ; per: string } | { kind: "scatter" ; x: unknown ; every: string ; origin: string ; max_gap: string ; method: "previous" | "next" | "nearest" | "linear" ; boundary: { before: "none" | "nearest" ; after: "none" | "nearest" } ; max_points: number ; fit: FitModel | null ; grid: { x: Bins ; y: Bins } | null } | { kind: "signal_distribution" ; bins: Bins } | { kind: "signal_summary" } | { kind: "signal_integral" ; unit: string } | { kind: "signal_windows" ; unit: WindowUnit } | { kind: "signal_chart" ; max_points: number } | { kind: "windows" ; unit: WindowUnit } | { kind: "periods" ; every: string ; origin: string ; closed: "start" | "end" ; label: "start" | "end" } | { kind: "sessions" ; gap: string } | { kind: "chart" ; max_points: number } | { kind: "episodes" ; origin: string ; min_micros: string } Not exported: an exported type refers to it.

Bins

Ƭ Bins: { kind: "count" ; lower: string ; upper: string ; count: number } | { kind: "width" ; lower: string ; upper: string ; width: string } Not exported: an exported type refers to it.

FitModel

Ƭ FitModel: { kind: "polynomial" ; degree: number } | { kind: "exponential" } Not exported: an exported type refers to it.

ExactResult

Ƭ ExactResult: { kind: "empty" } | { kind: "int64" ; value: bigint } | { kind: "float64" ; value: number } | { kind: "decimal" ; value: string ; scale: number } Not exported: an exported type refers to it.

PopulationEvidence

Ƭ PopulationEvidence: Object Not exported: an exported type refers to it.

Type declaration

Name	Type
`result?`	`SeriesResultDescriptor`
`population`	`"complete"` \| `"partial"`
`settlement`	{ `kind`: `"unknown"` } \| { `kind`: `"publisher_asserted"` ; `is_final`: `boolean` } \| { `kind`: `"source_settled"` ; `source_epoch`: `string` ; `frontier_receipt_id`: `string` ; `event_time_through`: `string` ; `contract_digest`: `string` } \| { `kind`: `"policy_closed"` ; `policy_digest`: `string` ; `event_time_through`: `string` ; `evaluated_at`: `string` }

SeriesResultDescriptor

Ƭ SeriesResultDescriptor: Object Not exported: an exported type refers to it.

Type declaration

Name	Type
`privacy`	`"scoped"` \| `"conservative"`
`identity`	`ResultIdentity`
`basis`	`JsonEvidence`
`evidence`	`ResultEvidence`

JsonEvidence

Ƭ JsonEvidence: null | string | number | boolean | JsonEvidence[] | { [key: string]: JsonEvidence; } Not exported: an exported type refers to it.

ResultIdentity

Ƭ ResultIdentity: Object Not exported: an exported type refers to it.

Type declaration

Name	Type
`definition_digest`	`string`
`question_id`	`string`
`result_digest`	`string`
`kernel`	`string`

SignalDistribution

Ƭ SignalDistribution: Object Not exported: an exported type refers to it.

Type declaration

Name	Type
`bins`	{ `from`: `ExactResult` ; `to`: `ExactResult` ; `duration_micros`: `bigint` }[]
`below_micros`	`bigint`
`above_micros`	`bigint`
`covered_micros`	`bigint`
`uncovered_micros`	`bigint`

Distribution

Ƭ Distribution: Object Not exported: an exported type refers to it.

Type declaration

Name	Type
`bins`	{ `from`: `ExactResult` ; `to`: `ExactResult` ; `count`: `bigint` }[]
`below`	`bigint`
`above`	`bigint`
`nulls`	`bigint`
`missing`	`bigint`

Joint

Ƭ Joint: Object Not exported: an exported type refers to it.

Type declaration

Name	Type
`x`	`ExactResult`[]
`y`	`ExactResult`[]
`counts`	`bigint`[]
`outside`	`bigint`

Fit

Ƭ Fit: Object Not exported: an exported type refers to it.

Type declaration

Name	Type
`model`	`FitModel`
`count`	`bigint`
`nulls`	`bigint`
`missing`	`bigint`
`excluded`	`bigint`
`coefficients`	`ExactResult`[]
`r_squared`	`ExactResult`
`sum_squared_residuals`	`ExactResult`
`residual_variance`	`ExactResult`

SignalFit

Ƭ SignalFit: Object Not exported: an exported type refers to it.

Type declaration

Name	Type
`model`	{ `kind`: `"polynomial"` ; `degree`: `number` }
`model.kind`	`"polynomial"`
`model.degree`	`number`
`coefficients`	`ExactResult`[]
`r_squared`	`ExactResult`
`integrated_squared_residuals`	`ExactResult`
`mean_squared_residual`	`ExactResult`
`covered_micros`	`bigint`
`uncovered_micros`	`bigint`

TrajectoryEndpoint

Ƭ TrajectoryEndpoint: Object Not exported: an exported type refers to it.

Type declaration

Name	Type
`time`	`bigint`
`longitude`	`number`
`latitude`	`number`
`accuracy_m`	`number` \| `null`
`is_observed`	`boolean`

TrajectorySupport

Ƭ TrajectorySupport: Object Not exported: an exported type refers to it.

Type declaration

Name	Type
`source_id`	`string`
`generation`	`bigint`
`event_id`	`string`
`event_key`	`string`
`time`	`bigint`
`order`	`bigint`
`admission_sequence`	`bigint`

TrajectorySegment

Ƭ TrajectorySegment: Object Not exported: an exported type refers to it.

Type declaration

Name	Type
`start`	`TrajectoryEndpoint`
`end`	`TrajectoryEndpoint`
`left`	`TrajectorySupport`
`right`	`TrajectorySupport`

TrajectoryFix

Ƭ TrajectoryFix: Object Not exported: an exported type refers to it.

Type declaration

Name	Type
`point`	`TrajectoryEndpoint`
`occurrence`	`TrajectorySupport`

Trajectory

Ƭ Trajectory: Object Not exported: an exported type refers to it.

Type declaration

Name	Type
`measure`	`null`
`coverage`	`Coverage`
`support_coverage`	`Coverage`
`population`	`"resolved"`
`profile`	`"wgs84-2d-great-elliptic-v1"` \| `"wgs84-2d-geodesic-v1"`
`position`	`string`
`max_gap`	`bigint`
`covered_micros`	`string`
`uncovered_micros`	`string`
`fixes`	`TrajectoryFix`[]
`segments`	`TrajectorySegment`[]

FleetTrajectories

Ƭ FleetTrajectories: Object Not exported: an exported type refers to it.

Type declaration

Name	Type
`measure`	`null`
`coverage`	`Coverage`
`support_coverage`	`Coverage`
`trajectories`	{ `series_id`: `string` ; `trajectory`: `Trajectory` }[]
`index`	{ `kind`: `"native_analysis"` } \| { `kind`: `"native_event_time"` ; `examined_headers`: `number` } \| { `kind`: `"native_space_time"` ; `examined_headers`: `number` ; `examined_cells`: `number` ; `dirty_series`: `number` }

TrajectoryIndexStatus

Ƭ TrajectoryIndexStatus: Object Not exported: an exported type refers to it.

Type declaration

Name	Type
`state`	`"rebuilding"` \| `"repairing"` \| `"ready"` \| `"dropping"` \| `"blocked"`
`cells`	`number`
`dirty_series`	`number`
`is_truncated`	`boolean`

Failure

Ƭ Failure: { reason: "cancelled" | "deadline" | "erased" | "retracted" | "expired" | "too_large" | "overflow" | "intervention" | "definition_changed" } | { reason: "bound" ; dimension: "headers" | "events" | "decoded_bytes" | "windows" | "historical_blocks" | "spatial_cells" | "encounter_pairs" | "expression" | "memory" | "time" } | { reason: "conflict" ; time: bigint ; order: bigint ; admission_sequence: bigint } Not exported: an exported type refers to it.

PagedTrajectoryAnalysis

Ƭ PagedTrajectoryAnalysis: Object Not exported: an exported type refers to it.

Type declaration

Name	Type
`state`	`"paged"`
`question_id`	`string`
`result_digest`	`string`
`manifest_digest`	`string`
`count`	`number`
`pages`	`number`
`evidence`	`Trajectory`

TrajectoryResultPage

Ƭ TrajectoryResultPage: Object Not exported: an exported type refers to it.

Type declaration

Name	Type
`state`	`"ready"`
`question_id`	`string`
`result_digest`	`string`
`manifest_digest`	`string`
`count`	`number`
`result`	`Trajectory`
`items`	({ `kind`: `"fix"` ; `fix`: `TrajectoryFix` } \| { `kind`: `"segment"` ; `segment`: `TrajectorySegment` })[]
`next_cursor`	`string` \| `null`

SeriesRetention

Ƭ SeriesRetention: { kind: "retain" } | { kind: "expire" ; micros: bigint } | { kind: "archive" ; micros: bigint } | { kind: "history" ; micros?: bigint } The retention of accepted native series events. Identity ends with expiry. An archive requirement prevents releasing the last payload copy until a native publication certifies the same accepted events.

SeriesArchiveOptions

Ƭ SeriesArchiveOptions: Object The change log of a series: one dataset row per accepted occurrence or retraction, read through the series resolution rule, which the deployment derives from the declaration and binds like any other dataset.

Type declaration

Name	Type	Description
`store`	`ResourceSlot`<`"datasetVersions"`>	-
`key?`	`string`	The dataset key. Default: the table name followed by `_archive`.
`labels?`	readonly `string`[]	The labels every archive version carries (at most 8 of `[a-z0-9:_-]{1,64}`); order and repeats are ignored.
`withhold?`	readonly `"values"`[]	Columns withheld from row previews. Default: `["values"]`, the payload cells and every geometry payload column; `[]` discloses them. Archive custody stores them exactly either way.
`nativeWindow?`	`bigint`	Microseconds of event time native blocks keep. An older hour leaves the native tier once the change log has confirmed it, and native reads that start before the window refuse with `SeriesHistoryInChangeLog`; read that history from the change log dataset. Omit to keep every block until retention.

SeriesAdmissionChange

Ƭ SeriesAdmissionChange<Fields>: Object Newly accepted occurrence changes checked in the final transaction. id is the native occurrence key, not an ordinary document id.

Type parameters

Name	Type
`Fields`	extends `Record`<`string`, `GenericValidator`>

Type declaration

Name	Type
`id`	`string`
`before`	`null`
`after`	`ReturnType`<typeof `occurrence`>[`"type"`] & { `generation`: `bigint` }

SeriesAdmissionRule

Ƭ SeriesAdmissionRule<Fields>: FunctionReference<"query", "public" | "internal", { changes: SeriesAdmissionChange<Fields>[] }, ReadAccessResults> | { query: FunctionReference<"query", "public" | "internal", { changes: SeriesAdmissionChange<Fields>[] }, ReadAccessResults> ; reads: readonly string[] | () => readonly string[] ; appliesDelegation?: boolean }

Type parameters

Name	Type
`Fields`	extends `Record`<`string`, `GenericValidator`>

SeriesMetadata

Ƭ SeriesMetadata: Object The admitted series contract carried by discovery. Exact retention is decimal text because this metadata is JSON.

Type declaration

Name	Type	Description
`ingestion?`	{ `kind`: `"application"` \| `"source"` }	-
`ingestion.kind`	`"application"` \| `"source"`	-
`source_settlement?`	{ `sources`: `string`[] ; `contract_digest`: `string` }	-
`source_settlement.sources`	`string`[]	-
`source_settlement.contract_digest`	`string`	-
`stream_settlement?`	`true`	-
`version`	`1` \| `2`	-
`values`	`GenericValidator`[`"json"`]	The exact payload admission accepts.
`key?`	`GenericValidator`[`"json"`]	-
`units?`	`Record`<`string`, `string`>	-
`retention`	{ `kind`: `"retain"` } \| { `kind`: `"expire"` \| `"archive"` ; `micros`: `string` } \| { `kind`: `"history"` ; `micros?`: `string` }	-
`decimal`	`Record`<`string`, `number`>	-
`trajectory_indexes?`	`string`[]	-
`resolution?`	{ `key`: `string` }	Resolve corrections independently for each required text key at an instant.
`resolution.key`	`string`	-
`interval?`	{ `to`: `string` ; `max_micros`: `string` }	Explicit support [event time, values[to]); no interpolation across gaps.
`interval.to`	`string`	-
`interval.max_micros`	`string`	-
`publication?`	`"window"`	Complete replaceable populations aligned to this source-time step.
`derivation?`	{ `producer`: `string` ; `member`: `string` }	The installed native program and its typed output member.
`derivation.producer`	`string`	-
`derivation.member`	`string`	-
`archive?`	{ `resource`: `string` ; `key?`: `string` ; `labels`: `string`[] ; `withhold`: `"values"`[] ; `identities?`: `Record`<`string`, `number`> ; `nativeWindow?`: `string` }	The declared recovery archive, with the identity ledger’s field identities once the bundler attaches them.
`archive.resource`	`string`	-
`archive.key?`	`string`	-
`archive.labels`	`string`[]	-
`archive.withhold`	`"values"`[]	-
`archive.identities?`	`Record`<`string`, `number`>	-
`archive.nativeWindow?`	`string`	-

SeriesOptions

Ƭ SeriesOptions<Fields>: Object

Type parameters

Name	Type
`Fields`	extends `Record`<`string`, `GenericValidator`>

Type declaration

Name	Type	Description
`ingestion?`	{ `kind`: `"application"` \| `"source"` }	-
`ingestion.kind`	`"application"` \| `"source"`	-
`key?`	`Record`<`string`, `GenericValidator`> \| `GenericValidator`	-
`units?`	`Partial`<`Record`<`Extract`<keyof `Fields`, `string`>, `string`>>	-
`retention?`	`SeriesRetention`	-
`resolution?`	{ `key`: `Extract`<keyof `Fields`, `string`> }	Independent observations at the same instant. Omit for one sample per instant.
`resolution.key`	`Extract`<keyof `Fields`, `string`>	-
`interval?`	{ `to`: `Extract`<keyof `Fields`, `string`> ; `max_micros`: `bigint` }	The exclusive interval end and the admitted maximum duration.
`interval.to`	`Extract`<keyof `Fields`, `string`>	-
`interval.max_micros`	`bigint`	-
`publication?`	`"window"`	Admit only complete window publications, including empty results.
`decimal?`	`Partial`<`Record`<`Extract`<keyof `Fields`, `string`>, `number`>>	Exact decimal text measures and their declared scales, from 0 to 38.
`archive?`	`SeriesArchiveOptions`	Keep a recovery archive of a retained series. An archive-retained series always has one, with these options or the defaults; an expiring series has none.

SampleMeasure

Ƭ SampleMeasure<V>: V extends Validator<infer Type, infer IsOptional, infer FieldPaths> ? Validator<Type | null, IsOptional, FieldPaths> : never A measure of a resolved sample: a quality withdrawal nulls it.

Type parameters

Name	Type
`V`	extends `GenericValidator`

SampleValues

Ƭ SampleValues<Fields>: { [Name in keyof Fields]: SampleMeasure<Fields[Name]> } The resolved values of one sample coordinate.

Type parameters

Name	Type
`Fields`	extends `Record`<`string`, `GenericValidator`>

SampleRecord

Ƭ SampleRecord<Fields, Key>: ReturnType<typeof object> One resolved sample: its canonical series identity, typed key, event time in microseconds and resolved values. A series’ logical table holds one per coordinate, ordered by its declared indexes.

Type parameters

Name	Type
`Fields`	extends `Record`<`string`, `GenericValidator`>
`Key`	extends `GenericValidator` = `VString`<`string`, `"required"`>

SeriesCoordinateIndexes

Ƭ SeriesCoordinateIndexes: Object Every series orders its sample coordinates.

Type declaration

Name	Type
`by_series_time`	[`"series"`, `"time"`, `"_creationTime"`]

SeriesEncounterOptions

Ƭ SeriesEncounterOptions: Object Continuous centre separation under an explicit distance model. Position accuracy remains separate from modeled movement and separation.

Type declaration

Name	Type
`metric`	`TrajectoryEncounterMetric`
`maxEncounters?`	`number`

SeriesEncounterPosition

Ƭ SeriesEncounterPosition: Object One path’s disclosed position and both accepted supporting occurrences. Interpolated positions have unknown accuracy.

Type declaration

Name	Type
`position`	`Position`
`is_observed`	`boolean`
`left`	`SeriesTrajectorySegment`[`"left"`]
`right`	`SeriesTrajectorySegment`[`"right"`]

SeriesEncounterBoundary

Ƭ SeriesEncounterBoundary: Object Modeled time, retained separately from any integer-time quantization. The requested upper boundary is excluded.

Type declaration

Name	Type
`time`	`SeriesTrajectoryTime`
`is_included`	`boolean`
`left`	`SeriesEncounterPosition`
`right`	`SeriesEncounterPosition`

SeriesEncounter

Ƭ SeriesEncounter: Object One maximal encounter over known continuous support from both paths. The independently addressable series identities form a canonical pair. A contact has zero duration; unknown gaps never join encounters.

Type declaration

Name	Type	Description
`left_series_id`	`string`	-
`right_series_id`	`string`	-
`start`	`SeriesEncounterBoundary`	-
`end`	`SeriesEncounterBoundary`	-
`duration_micros`	`number`	-
`closest`	{ `time`: `SeriesTrajectoryTime` ; `distance_m`: `number` ; `is_included`: `boolean` }	A minimum on the encounter’s closure. is_included=false identifies an infimum at the excluded query endpoint.
`closest.time`	`SeriesTrajectoryTime`	-
`closest.distance_m`	`number`	-
`closest.is_included`	`boolean`	-

SeriesFleetEncounters

Ƭ SeriesFleetEncounters: Object All modeled encounters in the disclosed input population. Completeness refers to that population, not unreported physical movement.

Type declaration

Name	Type	Description
`basis`	`string`	-
`coverage`	`SeriesFleetTrajectories`[`"coverage"`]	-
`support_coverage`	`SeriesFleetTrajectories`[`"support_coverage"`]	-
`metric`	`SeriesEncounterOptions`[`"metric"`]	-
`discovery`	{ `kind`: `"inline"` } \| { `kind`: `"captured"` ; `is_indexed`: `boolean` ; `members`: `number` ; `source_pairs`: `number` ; `examined_cells`: `number` ; `dirty_series`: `number` }	Captured source pairs are frozen with the admission basis. Dirty sources join discovery conservatively; counters never establish an encounter.
`is_complete`	`boolean`	-
`candidate_pairs`	`number`	-
`encounters`	`SeriesEncounter`[]	-

SeriesConflict

Ƭ SeriesConflict: Object Differing payloads at the greatest accepted order of one instant.

Type declaration

Name	Type
`kind`	`"series_conflict"`
`time`	`bigint`
`order`	`bigint`
`admission_sequence`	`bigint`

SeriesFailure

Ƭ SeriesFailure: SeriesConflict | { kind: "series_publication" ; reason: "selection_changed" | "equivalent_output_changed" | "erased" | "expired" | "unavailable" } | { kind: "series_history" ; reason: "unavailable" | "busy" | "basis_unavailable" | "work_limit" | "invalid_archive" | "excluded" } | { kind: "series_bound" ; dimension: "headers" | "events" | "decoded_bytes" | "windows" | "historical_blocks" | "spatial_cells" | "encounter_pairs" | "expression" | "memory" | "time" ; limit: number } | { kind: "series_argument" ; argument: "request" | "series" | "range" | "from" | "to" | "time" | "order" | "generation" | "fields" | "measure" | "limit" | "max_points" | "max_gap" | "expression" ; reason: "invalid" | "exact_integer_required" | "nonempty_bounded_name_required" | "start_after_end" | "unknown_field" | "out_of_range" | "boundary_overflow" } | { kind: "series_cursor" ; reason: "invalid" | "request_changed" | "unavailable" } | { kind: "series_work_required" ; dimension: "headers" | "events" | "decoded_bytes" | "windows" | "historical_blocks" | "memory" | "time" ; limit: number } | { kind: "series_operator_unavailable" ; operator: "certified_integral" | "continuous_equality" | "continuous_non_affine" | "customer_placement" } | { kind: "series_measure" ; measure: string ; available: string[] } Native refusals and classified historical fetch failures. An empty answer remains a successful value.

SeriesSignalAggregate

Ƭ SeriesSignalAggregate: "integral" | "covered_mean" | "covered_micros" | "uncovered_micros" Scalar reductions distinguish observations from continuous support.

SeriesFleetAggregate

Ƭ SeriesFleetAggregate: { kind: "interval_duration" } | SeriesAggregate | SeriesSignalAggregate | { kind: "signal_integral" ; unit: SeriesUnit }

SeriesFleetOptions

Ƭ SeriesFleetOptions<Expr>: Object

Type parameters

Name
`Expr`

Type declaration

Name	Type	Description
`population?`	`"declared"` \| `"caller_visible"`	Declared business totals refuse hidden named members. Caller-visible populations explicitly summarize only the current caller’s disclosed rows.
`key?`	(`row`: `RowReference`<`RelationRow`<`Expr`>>) => `unknown`	A unique string field of the complete population. By default every metric must belong to one object, whose native locator supplies its key.
`maxMembers?`	`number`	-
`limits?`	`ViewLimits`	-

Metrics

Ƭ Metrics: Record<string, TemporalScalar> Not exported: an exported type refers to it.

SeriesFleetAnalysisId

Ƭ SeriesFleetAnalysisId<Row, M>: string & { __seriesFleetAnalysis: { row: Row ; metrics: M } } An opaque location of one captured fleet; every read rechecks authority.

Type parameters

Name	Type
`Row`	`unknown`
`M`	extends `Metrics` = `Metrics`

SeriesFleetPage

Ƭ SeriesFleetPage<Row, M>: Object A globally ordered page, with shared evidence referenced by each metric.

Type parameters

Name	Type
`Row`	`Row`
`M`	extends `Metrics`

Type declaration

Name	Type
`population`	`ResultPopulation`
`items`	{ `key`: `string` ; `row`: `Row` ; `values`: { [K in keyof M]: SeriesMeasureResult \| (Extract<M[K][“aggregate”], Object> extends never ? never : Object) } ; `evidence`: { [K in keyof M]: number } }[]
`roots`	`Extract`<`SeriesExpressionResult`, { `output`: `"summary"` \| `"signal_summary"` \| `"signal_integral"` \| `"interval_duration"` }>[]
`cursor`	`string` \| `null`
`basis_id`	`string`
`execution`	{ `strategy`: `"complete_population"` \| `"prepared_population"` \| `"placed_population"` ; `distinct_roots`: `number` ; `shared_blocks`: `number` ; `placement?`: { `table`: `string` ; `members`: `number` ; `host`: `"warehouse"` \| `"worker"` ; `placement`: `SeriesPlacement` }[] }
`execution.strategy`	`"complete_population"` \| `"prepared_population"` \| `"placed_population"`
`execution.distinct_roots`	`number`
`execution.shared_blocks`	`number`
`execution.placement?`	{ `table`: `string` ; `members`: `number` ; `host`: `"warehouse"` \| `"worker"` ; `placement`: `SeriesPlacement` }[]

LineString

Ƭ LineString: Object Not exported: an exported type refers to it.

Type declaration

Name	Type
`type`	`"LineString"`
`coordinates`	`Coordinates`[]

SeriesTrajectoryFeature

Ƭ SeriesTrajectoryFeature: { type: "Feature" ; id: string } & { geometry: Point ; properties: { kind: "fix" ; time_micros: string ; accuracy_m: number | null ; event_key: string } } | { geometry: Point | LineString ; properties: { kind: "segment" ; from_micros: string ; to_micros: string ; left_event_key: string ; right_event_key: string ; part: number } } A JSON-serializable drawing of a native fix or segment. Microsecond times are decimal strings, so JSON and map engines preserve exact epochs. Segment times describe its whole native interval, including when rendering splits it into two parts at the antimeridian.

MapCoverage

Ƭ MapCoverage: Object Not exported: an exported type refers to it.

Type declaration

Name	Type
`from_micros`	`string`
`to_micros`	`string`
`visible_from_micros`	`string`
`is_complete`	`boolean`

SeriesTrajectoryGeoJSON

Ƭ SeriesTrajectoryGeoJSON: Object A map representation, retaining the answer’s basis and completeness. Features do not replace its accepted-occurrence evidence.

Type declaration

Name	Type
`type`	`"FeatureCollection"`
`basis`	`string`
`profile`	`SeriesTrajectory`[`"profile"`]
`coverage`	`MapCoverage`
`support_coverage`	`MapCoverage`
`covered_micros`	`string`
`uncovered_micros`	`string`
`features`	`SeriesTrajectoryFeature`[]

SeriesPlacement

Ƭ SeriesPlacement: { placement: "native_direct" | "native_prepared" | "warehouse" } | { placement: "worker" ; members_per_task: number } | { placement: "refused" ; refusals: { node: string | null ; code: string }[] } Where the native planner placed one group.

SeriesFleetGroup

Ƭ SeriesFleetGroup: Object One group of member roots that share a table and an expression.

Type declaration

Name	Type	Description
`table`	`string`	-
`expression`	{ `node`: `SeriesExpressionNode` ; `output`: { `kind`: `string` } ; `max_gap?`: `string` \| `null` ; `shift?`: `string` \| `null` }	-
`expression.node`	`SeriesExpressionNode`	-
`expression.output`	{ `kind`: `string` }	-
`expression.output.kind`	`string`	-
`expression.max_gap?`	`string` \| `null`	-
`expression.shift?`	`string` \| `null`	-
`series`	`string`[]	Member series, in root order.
`kind`	{ `kind`: `"number"` ; `value`: `SeriesMeasureKind` } \| { `kind`: `string` }	-
`measures`	{ `column`: `string` ; `kind`: `SeriesMeasureKind` ; `unit`: `string` \| `null` }[]	The measures the expression reads, for a worker’s input catalog.
`placement`	`SeriesPlacement`	-

SeriesMeasureKind

Ƭ SeriesMeasureKind: { kind: "int64" } | { kind: "float64" } | { kind: "decimal" ; scale: number } Not exported: an exported type refers to it.

SeriesWorkerResult

Ƭ SeriesWorkerResult: Object One member answer from a worker: the shared evaluator’s JSON answer for member, the series it was evaluated on.

Type declaration

Name	Type
`member`	`string`
`result`	`string`

SeriesFleetHosts

Ƭ SeriesFleetHosts: Object The hosts a caller admits for one placed fleet. A native bound never selects a host that is not listed.

Type declaration

Name	Type	Description
`warehouse?`	{ `runs`: `Pick`<`RunClient`<`any`>, `"capturePlan"`> ; `executor`: `SourceHandle` ; `resources?`: `AnalyticalResources` ; `approximate?`: `boolean` }	A warehouse executor: each group becomes archive questions over the series change log, retained by the run owner.
`warehouse.runs`	`Pick`<`RunClient`<`any`>, `"capturePlan"`>	-
`warehouse.executor`	`SourceHandle`	-
`warehouse.resources?`	`AnalyticalResources`	-
`warehouse.approximate?`	`boolean`	Admit binary64 warehouse accumulation (relative tolerance 1e-9).
`worker?`	{ `start`: (`group`: `SeriesFleetGroup` & { `from`: `bigint` ; `to`: `bigint` }) => `Promise`<`unknown`> ; `answers`: (`run`: `unknown`) => `Promise`<readonly `SeriesWorkerResult`[] \| `null`> }	A customer function host: `start` begins a Compute run of the application’s function (which calls `bijection_series.spark`) for one group, and `answers` reads that run’s accepted output Dataset, or null while it is pending.
`worker.start`	[object Object]	-
`worker.answers`	[object Object]	-

PlannedMember

Ƭ PlannedMember: Object Not exported: an exported type refers to it.

Type declaration

Name	Type
`key`	`string`
`row`	`unknown`
`metrics`	`Record`<`string`, { `root`: `bigint` \| `number` ; `aggregate`: `unknown` }>

SeriesFleetPlanPage

Ƭ SeriesFleetPlanPage: Object One planned page of a placed population, as 1.0/series/external answers it. Return it from the query that plans it; it holds no authority.

Type declaration

Name	Type	Description
`population`	`ResultPopulation`	-
`members`	`PlannedMember`[]	-
`groups`	`SeriesFleetGroup` & { `roots`: (`bigint` \| `number`)[] }[]	-
`native_only`	(`bigint` \| `number`)[]	-
`basis_id`	`string`	The population’s question and pinned snapshot; equal on every page.
`page_id`	`string`	-
`population_snapshot`	`string`	-
`after`	`string` \| `null`	The planning cursor this page started after (null for the first).
`cursor`	`string`	The retained planning cursor to plan the next page from.
`is_done`	`boolean`	-
`from`	`bigint`	-
`to`	`bigint`	-
`order`	{ `field`: `string` ; `descending`: `boolean` } \| `null`	-

DispatchedGroup

Ƭ DispatchedGroup: SeriesFleetGroup & { host: "warehouse" | "worker" ; requests: readonly unknown[] ; run: unknown } Not exported: an exported type refers to it.

PlacedSeriesFleet

Ƭ PlacedSeriesFleet<Page>: Object A placed fleet: the pages planned so far and each group’s retained work.

Type parameters

Name
`Page`

Type declaration

Name	Type	Description
`basis_id`	`string` \| `null`	The population basis every page must share; null before a page.
`cursor`	`string` \| `null`	The retained planning cursor: plan the next page after it.
`isDone`	`boolean`	-
`groups`	readonly `DispatchedGroup`[]	-
`dispatch`	(`page`: `SeriesFleetPlanPage`) => `Promise`<{ `cursor`: `string` ; `isDone`: `boolean` }>	Start one planned page’s groups on their admitted hosts. Pages arrive in cursor order from one population snapshot; another snapshot, question, repeated or skipped page refuses before anything starts.
`read`	(`options?`: { `limit?`: `number` ; `cursor?`: `string` \| `null` }) => `Promise`<{ `state`: `"pending"` } \| { `state`: `"ready"` ; `page`: `Page` }>	Once the last page is dispatched, read every group’s accepted answers and assemble one page of the whole population.

SeriesExpressionOutput

Ƭ SeriesExpressionOutput: { kind: "states" ; limit: number } | { kind: "intervals" ; min_micros: string } | { kind: "interval_duration" ; min_micros: string } | { kind: "samples" } | { kind: "sampled" ; every: string ; origin: string ; domain_errors: "reject" | "absent" ; zero_tolerance: string } | { kind: "resample" ; every: string ; origin: string ; max_gap: string ; method: "previous" | "next" | "nearest" | "linear" ; boundary: { before: "none" | "nearest" ; after: "none" | "nearest" } } | { kind: "summary" } | { kind: "distribution" ; bins: Bins ; others: SeriesExpressionNode[] } | { kind: "scatter" ; x: SeriesExpressionNode ; every: string ; origin: string ; max_gap: string ; method: "previous" | "next" | "nearest" | "linear" ; boundary: { before: "none" | "nearest" ; after: "none" | "nearest" } ; max_points: number ; fit: FitModel | null ; grid: { x: Bins ; y: Bins } | null } | { kind: "regression" ; model: FitModel ; origin: string ; per: string } | { kind: "signal_distribution" ; bins: Bins } | { kind: "signal_regression" ; model: FitModel ; origin: string ; per: string } | { kind: "signal_summary" } | { kind: "signal_integral" ; unit: string } | { kind: "signal_windows" ; unit: CalendarWindow } | { kind: "signal_chart" ; max_points?: number } | { kind: "windows" ; unit: CalendarWindow } | { kind: "periods" ; every: string ; origin: string ; closed: "start" | "end" ; label: "start" | "end" } | { kind: "sessions" ; gap: string } | { kind: "chart" ; max_points?: number } | { kind: "episodes" ; origin: string ; min_micros: string } Not exported: an exported type refers to it.

SeriesTrajectoryTime

Ƭ SeriesTrajectoryTime: Object A modeled time between exact microsecond anchors. The binary64 fraction is geometric interpolation, never a floating-point absolute epoch.

Type declaration

Name	Type
`from`	`bigint`
`to`	`bigint`
`fraction`	`number`

SeriesTrajectoryVisitBoundary

Ƭ SeriesTrajectoryVisitBoundary: Object Evidence for one end of a modeled visit. continuity means the available path begins or ends there; it does not establish an entrance or exit. Interpolated positions have unknown accuracy.

Type declaration

Name	Type
`time`	`SeriesTrajectoryTime`
`position`	`Position`
`is_observed`	`boolean`
`is_included`	`boolean`
`cause`	`"crossing"` \| `"window"` \| `"continuity"`
`left`	`SeriesTrajectorySegment`[`"left"`]
`right`	`SeriesTrajectorySegment`[`"right"`]

SeriesTrajectoryVisit

Ƭ SeriesTrajectoryVisit: Object A connected region visit under the native trajectory’s path and gap model. Dwell is binary64 microseconds of modeled continuity, with contacts contributing zero. It is not evidence of unobserved physical motion.

Type declaration

Name	Type
`start`	`SeriesTrajectoryVisitBoundary`
`end`	`SeriesTrajectoryVisitBoundary`
`dwell_micros`	`number`

SeriesTrajectoryVisits

Ƭ SeriesTrajectoryVisits: Object A bounded derived answer at exactly the input trajectory’s basis. Its completeness requires both requested and boundary-support coverage.

Type declaration

Name	Type
`basis`	`string`
`profile`	`SeriesTrajectory`[`"profile"`]
`position`	`string`
`max_gap`	`bigint`
`region`	`Geometry` \| `Box`
`coverage`	`SeriesCoverage`
`support_coverage`	`SeriesCoverage`
`is_complete`	`boolean`
`dwell_micros`	`number`
`visits`	`SeriesTrajectoryVisit`[]

ScalarKey

Ƭ ScalarKey: Validator<string, "required", any> Not exported: an exported type refers to it.

SeriesKeyValue

Ƭ SeriesKeyValue<Key>: Key extends GenericValidator ? Key["type"] : { [K in keyof Key]: Key[K] extends GenericValidator ? Key[K][“type”] : never } Not exported: an exported type refers to it.

Type parameters

Name	Type
`Key`	extends `SeriesKeyDefinition`

SeriesKeyValidator

Ƭ SeriesKeyValidator<Key>: Key extends GenericValidator ? Key : ReturnType<typeof object> The validator of a series’ typed key in its sample records.

Type parameters

Name	Type
`Key`	extends `SeriesKeyDefinition`

SampleFieldPath

Ƭ SampleFieldPath<Fields, Key>: SampleRecord<Fields, SeriesKeyValidator<Key>>["fieldPaths"] | keyof SystemFields The field paths a series index may order: the sample record’s.

Type parameters

Name	Type
`Fields`	extends `Record`<`string`, `GenericValidator`>
`Key`	extends `SeriesKeyDefinition`

SampleType

Ƭ SampleType<Fields, Key>: SeriesTableDefinition<Fields, SeriesKeyValidator<Key>>["validator"]["type"] Not exported: an exported type refers to it.

Type parameters

Name	Type
`Fields`	extends `Record`<`string`, `GenericValidator`>
`Key`	extends `SeriesKeyDefinition`

EventField

Ƭ EventField<Fields, Key>: Extract<keyof SampleType<Fields, Key>, string> Not exported: an exported type refers to it.

Type parameters

Name	Type
`Fields`	extends `Record`<`string`, `GenericValidator`>
`Key`	extends `SeriesKeyDefinition`

PermissionOf

Ƭ PermissionOf<Resource>: Resource extends AccessResource<any, infer Permission> ? Permission : never Not exported: an exported type refers to it.

Type parameters

Name	Type
`Resource`	extends `AccessResource`

AccessOptions

Ƭ AccessOptions<Fields, Key, Resource, Binding>: AccessResourceBinding<EventField<Fields, Key>, PermissionOf<Resource>, SampleType<Fields, Key>, Resource extends AccessResource<any, any, any, infer Definition> ? Definition : never> & CheckedAccessBinding<Binding, PermissionOf<Resource>, EventField<Fields, Key>, SampleType<Fields, Key>> Not exported: an exported type refers to it.

Type parameters

Name	Type
`Fields`	extends `Record`<`string`, `GenericValidator`>
`Key`	extends `SeriesKeyDefinition`
`Resource`	extends `AccessResource`
`Binding`	extends `object`

TrajectoryEvaluation

Ƭ TrajectoryEvaluation: Object Not exported: an exported type refers to it.

Type declaration

Name	Type
`kind`	`TemporalKind`
`trajectory`	`JsonValue`
`region`	`JsonValue` \| `null`

TrajectoryTimeRounding

Ƭ TrajectoryTimeRounding: "floor" | "ceil" | "nearest" Not exported: an exported type refers to it.

CursorValueKind

Ƭ CursorValueKind: "position" | "scalar" Not exported: an exported type refers to it.

TemporalKind

Ƭ TemporalKind: "trajectory" | "visits" | "dwell" Not exported: an exported type refers to it.

SerializedReference

Ƭ SerializedReference: Object Not exported: an exported type refers to it.

Type declaration

Name	Type
`version`	`1`
`as?`	`string`
`to?`	{ `interface`: `string` }
`to.interface`	`string`
`inverse`	{ `as?`: `string` ; `min`: `number` ; `max`: `number` \| `null` }
`inverse.as?`	`string`
`inverse.min`	`number`
`inverse.max`	`number` \| `null`

ResolvedSeriesSample

Ƭ ResolvedSeriesSample<Subject, Value>: Object Not exported: an exported type refers to it.

Type parameters

Name
`Subject`
`Value`

Type declaration

Name	Type
`subject`	`Subject`
`time_us`	`bigint`
`value`	`Value`
`unit`	`SeriesUnit`

Fields

Ƭ Fields: Record<string, GenericValidator> Not exported: an exported type refers to it.

LinkDefinition

Ƭ LinkDefinition: Object Not exported: an exported type refers to it.

Type declaration

Name	Type
`version`	`1`
`symmetric?`	`true`
`endpoints`	`Record`<`string`, { `min`: `number` ; `max`: `number` \| `null` ; `to?`: { `interface`: `string` } } & `LinkEndpointNames`>

AnalysisDuration

Ƭ AnalysisDuration: bigint | string An exact duration: microseconds, or text such as "30s" or "1h".

Aggregate

Ƭ Aggregate<Result>: Object One aggregate of an analysis, typed by its answer.

Type parameters

Name
`Result`

Type declaration

Name	Type	Description
`kind`	`string`	-
`field?`	`string`	-
`[analysisAggregate]`	`true`	-
`__result?`	`Result`	Type-only answer marker.

Measure

Ƭ Measure<Path>: string extends Path ? string : Extract<Path, `values.${string}`> Not exported: an exported type refers to it.

Type parameters

Name	Type
`Path`	extends `string`

AnalysisAggregates

Ƭ AnalysisAggregates<Row, Paths, Signal, DecimalFields>: Signal extends true ? { timeWeightedMean: () => Aggregate<SeriesMeasureResult> ; supportedDuration: () => Aggregate<bigint> ; integral: () => Aggregate<SeriesMeasureResult> } : { count: () => Aggregate<bigint> ; sum: <Path>(field: Path) => Aggregate<SeriesMeasureResult> ; mean: <Path>(field: Path) => Aggregate<SeriesMeasureResult> ; min: <Path>(field: Path) => Aggregate<Exclude<FieldTypeFromFieldPath<Row, Path>, undefined> | null> ; max: <Path>(field: Path) => Aggregate<Exclude<FieldTypeFromFieldPath<Row, Path>, undefined> | null> ; first: <Path>(field: Path) => Aggregate<Exclude<FieldTypeFromFieldPath<Row, Path>, undefined> | null> ; last: <Path>(field: Path) => Aggregate<Exclude<FieldTypeFromFieldPath<Row, Path>, undefined> | null> } Schema-bound sample and signal aggregates.

Type parameters

Name	Type
`Row`	extends `GenericDocument`
`Paths`	extends `string`
`Signal`	extends `boolean` = `false`
`DecimalFields`	extends `string` = `never`

SignalPolicy

Ƭ SignalPolicy<Path>: Object Interpretation of one series’ samples over time. Interpolation never crosses maxGap; gaps remain missing support.

Type parameters

Name	Type
`Path`	extends `string`

Type declaration

Name	Type
`field`	`Measure`<`Path`>
`method`	`"previous"` \| `"linear"`
`maxGap`	`AnalysisDuration`

WindowSpec

Ƭ WindowSpec: { every: AnalysisDuration ; origin?: bigint ; calendar?: never } | { calendar: SeriesWindowUnit ; coordinates?: CalendarOptions ; every?: never ; origin?: never } Start-closed fixed-duration grids, or native UTC calendar windows.

ResultsOf

Ƭ ResultsOf<Aggregates>: { -readonly [Name in keyof Aggregates]: Aggregates[Name] extends Aggregate<infer Result> ? Result : never } The answers of named aggregates.

Type parameters

Name	Type
`Aggregates`	extends `Record`<`string`, `Aggregate`<`unknown`>>

AnalysisRow

Ƭ AnalysisRow<Results, Grouped, Windowed>: Expand<Grouped extends true ? { group: Value | null } : {} & Windowed extends true ? { window: { start: bigint ; end: bigint } } : {} & Results> One answer row of a grouped or windowed analysis.

Type parameters

Name	Type
`Results`	`Results`
`Grouped`	extends `boolean`
`Windowed`	extends `boolean`

AnalysisResult

Ƭ AnalysisResult<T>: SeriesEvaluationOf<IndexedAnalysisResult<T>> An analysis answer, independent of how it was computed.

Type parameters

Name
`T`

AnalysisExecution

Ƭ AnalysisExecution: Object Physical work; never part of an answer’s identity.

Type declaration

Name	Type
`recordsRead`	`bigint`
`neighboursRead`	`bigint`

AnalysisRead

Ƭ AnalysisRead<T>: SeriesReadFor<IndexedAnalysisResult<T>, AnalysisExecution>

Type parameters

Name
`T`

IndexedSeriesRun

Ƭ IndexedSeriesRun<T>: string & { __indexedSeriesResult: T } An opaque indexed run. Its result type is retained by the generated API.

Type parameters

Name
`T`

SeriesReportDefinition

Ƭ SeriesReportDefinition<Args, Definition>: Object Declare an ordinary table binding original report arguments to a native run. Add its normal access policy and writers in the schema. It owns no work.

Type parameters

Name	Type
`Args`	extends `PropertyValidators`
`Definition`	extends `string` = `string`

Type declaration

Name	Type
`definition`	`Definition`
`args`	`VObject`<`ObjectType`<`Args`>, `Args`>

ImmutableRequestFields

Ƭ ImmutableRequestFields<Fields, Read, Create>: { [Key in keyof Fields]: Object & (Fields[Key] extends VObject<any, infer Children extends PropertyValidators> ? Object : Object) } Not exported: an exported type refers to it.

Type parameters

Name	Type
`Fields`	extends `PropertyValidators`
`Read`	extends `string`
`Create`	extends `string`

CalendarCoordinates

Ƭ CalendarCoordinates: Object Captured calendar meaning; every native question retains all coordinates.

Type declaration

Name	Type
`zone`	`string`
`rules`	`"proleptic_gregorian_monday_v1"`
`tzdb`	`"iana:2026c/jiff-tzdb:0.1.8"`
`fold`	`"earlier"` \| `"later"` \| `"reject"`
`gap`	`"shift_forward"` \| `"reject"`

CalendarOptions

Ƭ CalendarOptions: { zone: string } & Partial<Omit<CalendarCoordinates, "zone">> Calendar choices for a window. Rules and tzdb may be asserted explicitly.

CalendarWindow

Ƭ CalendarWindow: Object

Type declaration

Name	Type
`unit`	`SeriesWindowUnit`
`coordinates`	`CalendarCoordinates`

SeriesKeys

Ƭ SeriesKeys<Row>: readonly SeriesFields<Row, string | bigint | boolean>[] Not exported: an exported type refers to it.

Type parameters

Name
`Row`

SeriesMeasures

Ƭ SeriesMeasures<Row>: Record<string, { field: SeriesFields<Row, number | bigint | null> ; unit: SeriesUnit }> Not exported: an exported type refers to it.

Type parameters

Name
`Row`

SeriesObservations

Ƭ SeriesObservations<Row>: { kind: "revisable" ; key: readonly SeriesFields<Row, string | bigint | boolean>[] ; withdrawal: SeriesFields<Row, boolean> | null ; order: SeriesFields<Row, bigint> } | { kind: "resolved" } Not exported: an exported type refers to it.

Type parameters

Name
`Row`

SeriesContract

Ƭ SeriesContract<Row, Key, Measures, Observations>: Readonly<{ key: Key ; time: SeriesFields<Row, Instant> ; observations: Observations ; measures: Measures }> Temporal meaning independent of source placement, version custody or access. Time is signed Unix epoch microseconds. Revisable observations resolve their greatest correction before windowing; conflicting winners refuse. Null is a reported missing value; an explicit withdrawal removes the identified observation. Resolved populations refuse duplicate key/time pairs.

Type parameters

Name	Type
`Row`	`Row`
`Key`	extends `SeriesKeys`<`Row`> = `SeriesKeys`<`Row`>
`Measures`	extends `SeriesMeasures`<`Row`> = `SeriesMeasures`<`Row`>
`Observations`	extends `SeriesObservations`<`Row`> = `SeriesObservations`<`Row`>

SeriesAggregate

SeriesComparison

Ƭ SeriesComparison: "lt" | "lte" | "gt" | "gte" | "eq" | "ne"

SeriesCombination

SeriesElementaryFunction

Ƭ SeriesElementaryFunction: "sqrt" | "cbrt" | "exp" | "ln" | "log10" | "log2" | "sin" | "cos" | "tan" | "asin" | "acos" | "atan" | "sinh" | "cosh" | "tanh" Not exported: an exported type refers to it.

SeriesRounding

Ƭ SeriesRounding: "half_away_from_zero" | "half_even" | "floor" | "ceil" Not exported: an exported type refers to it.

SeriesBitwiseOperator

Ƭ SeriesBitwiseOperator: "and" | "or" | "xor" | "shift_left" | "shift_right" Not exported: an exported type refers to it.

SeriesUnit

Ƭ SeriesUnit: "us" | "ms" | "s" | "min" | "h" | "delta:°C" | "delta:°F" | "delta:K" | "1" | "ppm" | "V" | "mV" | "kV" | "A" | "mA" | "°C" | "°F" | "K" | "m" | "km" | "ft" | "mi" | "m/s" | "km/h" | "mph" | "kn" | "W" | "kW" | "MW" | "J" | "Wh" | "kWh" | "Pa" | "kPa" | "bar" | "psi" Units of one dimension convert into each other.

SeriesExpressionNode

Ƭ SeriesExpressionNode: { op: "measure" ; measure: string ; series?: string ; property?: string } | { op: "combine" ; left: SeriesExpressionNode ; right: SeriesExpressionNode ; operator: SeriesCombination } | { op: "add" | "subtract" | "multiply" | "divide" | "min" | "max" ; input: SeriesExpressionNode ; operand: string } | { op: "signal" ; input: SeriesExpressionNode ; interpolation: "previous" | "linear" | "next" | "nearest" ; max_gap: string } | { op: "interval_signal" ; input: SeriesExpressionNode ; until: SeriesExpressionNode ; max_width: string } | { op: "negate" | "absolute" | "delta" | "not" ; input: SeriesExpressionNode } | { op: "convert" ; input: SeriesExpressionNode ; from: string ; to: string } | { op: "rate" ; input: SeriesExpressionNode ; per: string } | { op: "rolling" ; input: SeriesExpressionNode ; micros: string ; aggregate: string ; observations?: string } | { op: "signal_rolling" ; input: SeriesExpressionNode ; micros: string ; aggregate: "mean" | "integral" | "covered_mean" } | { op: "signal_cumulative" ; input: SeriesExpressionNode ; origin: string } | { op: "cumulative" ; input: SeriesExpressionNode ; aggregate: string ; origin: string } | { op: "compare" ; input: SeriesExpressionNode ; comparison: SeriesComparison ; operand: string } | { op: "compare_quantity" ; input: SeriesExpressionNode ; comparison: SeriesComparison ; operand: string ; from: string ; to: string } | { op: "and" | "or" ; inputs: SeriesExpressionNode[] } | { op: "power" ; input: SeriesExpressionNode ; exponent: string } | { op: "function" ; input: SeriesExpressionNode ; function: SeriesElementaryFunction } | { op: "round" ; input: SeriesExpressionNode ; rounding: SeriesRounding ; scale: string } | { op: "remainder" ; input: SeriesExpressionNode ; operand: string } | { op: "bitwise" ; input: SeriesExpressionNode ; operator: SeriesBitwiseOperator ; operand: string } | { op: "conditional" ; condition: SeriesExpressionNode ; when_true: SeriesExpressionNode ; when_false: SeriesExpressionNode } | { op: "filter" ; input: SeriesExpressionNode ; condition: SeriesExpressionNode } The wire form of one operator. Durations are microseconds and constants exact decimal text.

SeriesTimeWindow

Ƭ SeriesTimeWindow: { weight: "time" ; coverage: "complete" ; aggregate?: "mean" | "integral" } | { weight: "time" ; coverage: "covered" ; aggregate?: "mean" } A time-weighted trailing window. Covered means divide by known support rather than the full duration, and remain absent when that support is empty.

SeriesExpressionValue

Ƭ SeriesExpressionValue: { kind: "absent" } | { kind: "null" } | { kind: "number" ; value: number | bigint | string } | { kind: "truth" ; value: boolean | null } | { kind: "string" ; value: string } | { kind: "boolean" ; value: boolean } One expression value at an output instant.

SeriesExpressionAggregate

Ƭ SeriesExpressionAggregate: Object Every aggregate of one population of expression values.

Type declaration

Name	Type
`count`	`bigint`
`nulls`	`bigint`
`missing`	`bigint`
`min`	`SeriesMeasureResult`
`max`	`SeriesMeasureResult`
`first`	`SeriesMeasureResult`
`last`	`SeriesMeasureResult`
`sum`	`SeriesMeasureResult`
`product`	`SeriesMeasureResult`
`mean`	`SeriesMeasureResult`
`stddev`	`SeriesMeasureResult`
`difference`	`SeriesMeasureResult`
`relative_difference`	`SeriesMeasureResult`

SeriesEpisode

Ƭ SeriesEpisode: Object A half-open interval [start, end) over which a condition held, in microseconds. A crossing between two observations is solved in binary64 on that segment and rounded to the microsecond.

Type declaration

Name	Type	Description
`id`	`string`	-
`start`	`bigint`	-
`end`	`bigint` \| `null`	Exclusive; null while still holding at the end of the examined history.
`start_cause`	`"crossing"` \| `"observed"`	-
`end_cause`	`"false"` \| `"unknown"` \| `"gap"` \| `null`	-
`is_clipped`	`boolean`	No earlier interval has been decided since the declared origin, so the onset may be earlier. Narrowing a read never changes this flag.

SeriesResultIdentity

Ƭ SeriesResultIdentity: Object What an expression answer names: the question (definition, basis identity and scope), the result, and the kernel (engine and function library revision) that computed it. An upgrade may change binary64 results; the kernel in the answer says so.

Type declaration

Name	Type
`definition_digest`	`string`
`question_id`	`string`
`result_digest`	`string`
`kernel`	`string`

SeriesResultEvidence

Ƭ SeriesResultEvidence: ResultEvidence Independent source, support, execution and retention evidence.

Located

Ƭ Located: Object Not exported: an exported type refers to it.

Type declaration

Name	Type
`measure`	`string`
`basis`	`string`
`coverage`	`SeriesCoverage`
`context_from`	`bigint`
`identity`	`SeriesResultIdentity`
`evidence`	`SeriesResultEvidence`

SeriesExpressionSamples

Ƭ SeriesExpressionSamples: Located & { output: "samples" ; points: { time: bigint ; value: SeriesExpressionValue }[] ; next: bigint | null }

SeriesExpressionWindows

Ƭ SeriesExpressionWindows: Located & { output: "windows" ; windows: { from: bigint ; to: bigint ; is_excluded: boolean ; aggregate: SeriesExpressionAggregate }[] }

SeriesExpressionPeriods

Ƭ SeriesExpressionPeriods: Located & { output: "periods" ; periods: { from: bigint ; to: bigint ; time: bigint ; is_partial: boolean ; is_excluded: boolean ; aggregate: SeriesExpressionAggregate }[] } Not exported: an exported type refers to it.

SeriesExpressionChart

Ƭ SeriesExpressionChart: Located & { output: "chart" ; is_reduced: boolean ; buckets: { from: bigint ; to: bigint ; resolved_sample_count: bigint ; missing_count: bigint ; null_count: bigint ; is_excluded: boolean ; is_gap_present: boolean ; points: { time: bigint ; value: number | bigint | string }[] }[] }

SeriesExpressionSummary

Ƭ SeriesExpressionSummary: Located & { output: "summary" ; aggregate: SeriesExpressionAggregate }

SeriesExpressionDistribution

Ƭ SeriesExpressionDistribution: Located & { output: "distribution" ; distributions: SeriesDistribution[] } Not exported: an exported type refers to it.

SeriesExpressionSignalDistribution

Ƭ SeriesExpressionSignalDistribution: Located & { output: "signal_distribution" ; distribution: SignalDistribution } Supported time in half-open value bins, in whole microseconds. Unknown signal support remains uncovered duration. Crossings are solved on each segment between observations; a value equal to the upper edge belongs to the above range.

SeriesExpressionSignalRegression

Ƭ SeriesExpressionSignalRegression: Located & { output: "signal_regression" ; fit: SignalFit } Integrated binary64 polynomial least squares over supported physical time.

SeriesDistribution

Ƭ SeriesDistribution: Distribution Not exported: an exported type refers to it.

SeriesExpressionScatter

Ƭ SeriesExpressionScatter: Located & { output: "scatter" ; points: { time: bigint ; x: number | bigint | string ; y: number | bigint | string }[] ; next: bigint | null ; aligned: bigint ; x_only: bigint ; y_only: bigint ; neither: bigint ; fit: SeriesFit | null ; grid: Joint | null } Not exported: an exported type refers to it.

SeriesFitModel

Ƭ SeriesFitModel: FitModel Not exported: an exported type refers to it.

SeriesFit

Ƭ SeriesFit: Fit Not exported: an exported type refers to it.

SeriesExpressionRegression

Ƭ SeriesExpressionRegression: Located & SeriesFit & { output: "regression" } Not exported: an exported type refers to it.

SeriesExpressionSignalSummary

Ƭ SeriesExpressionSignalSummary: Located & { output: "signal_summary" ; covered_micros: bigint ; uncovered_micros: bigint ; integral: ExactResult ; covered_mean: ExactResult ; interval_mean: ExactResult | { kind: "incomplete" } } Time-weighted binary64 output of a continuously composed property; durations are whole microseconds.

SeriesExpressionIntegral

Ƭ SeriesExpressionIntegral: Located & { output: "signal_integral" ; unit: string ; value: ExactResult | { kind: "incomplete" } ; covered_micros: bigint ; uncovered_micros: bigint } A complete-support integral, converted under the admitted unit catalog. Missing support produces an incomplete value, never a partial integral.

SeriesExpressionSignalWindows

Ƭ SeriesExpressionSignalWindows: Located & { output: "signal_windows" ; windows: { from: bigint ; to: bigint ; is_excluded: boolean ; summary: Omit<SeriesExpressionSignalSummary, keyof Located | "output"> }[] } Composed signal summaries in UTC calendar windows.

SeriesExpressionSignalChart

Ƭ SeriesExpressionSignalChart: Located & { output: "signal_chart" ; projection: "time_weighted_mean" ; buckets: { from: bigint ; to: bigint ; is_excluded: boolean ; summary: Omit<SeriesExpressionSignalSummary, keyof Located | "output"> }[] } Display buckets summarize the original signal. Their values are time-weighted means, with explicit coverage rather than sampled extrema.

SeriesExpressionEpisodes

Ƭ SeriesExpressionEpisodes: Located & { output: "episodes" ; episodes: SeriesEpisode[] }

SeriesExpressionStates

Ƭ SeriesExpressionStates: Located & { output: "states" ; states: { from: bigint ; to: bigint ; value: string | boolean | null }[] ; next: bigint | null } Maximal half-open categorical intervals. Null means unknown support.

SeriesIntervalRange

Ƭ SeriesIntervalRange: Object One half-open component [from, to) of temporal membership in a finite query range, in microseconds.

Type declaration

Name	Type
`from`	`bigint`
`to`	`bigint`
`is_from_clipped`	`boolean`
`is_to_clipped`	`boolean`

SeriesExpressionIntervals

Ƭ SeriesExpressionIntervals: Located & { output: "intervals" ; intervals: SeriesIntervalRange[] ; unknown: SeriesIntervalRange[] } Qualified true components and explicit unknown membership.

SeriesExpressionResult

SeriesExpressionOptions

Ƭ SeriesExpressionOptions: Object The maximum gap operators relating two instants require, and an exact shift of output time.

Type declaration

Name	Type
`maxGap?`	`bigint`
`shift?`	`bigint`

SeriesArchiveOutput

Ƭ SeriesArchiveOutput: { kind: "samples" } | { kind: "windows" ; every: SeriesWindowUnit ; calendar?: CalendarOptions } | { kind: "periods" ; every: bigint ; origin?: bigint ; closed?: "start" | "end" ; label?: "start" | "end" } | { kind: "sessions" ; gap: bigint } | { kind: "distribution" ; bins: Bins ; others?: readonly SeriesNumbers[] } | { kind: "summary" } | { kind: "episodes" ; origin: bigint ; minDuration?: bigint } | { kind: "resample" ; every: bigint ; origin: bigint ; maxGap: bigint ; method: "previous" | "next" | "nearest" | "linear" ; boundary?: { before: "none" | "nearest" ; after: "none" | "nearest" } } | { kind: "chart" ; maxPoints: number } | { kind: "signal_summary" } | { kind: "signal_integral" ; unit: string } | { kind: "signal_windows" ; every: SeriesWindowUnit ; calendar?: CalendarOptions } | { kind: "signal_chart" ; maxPoints: number } What an archive question asks per series: the native expression outputs an archive plan can express.

SeriesPopulationOutputs

Ƭ SeriesPopulationOutputs: Object Original run outputs shared by archive and virtual-family captures.

Type declaration

Name	Type
`rows`	{ `kind`: `"table"` ; `row`: `SeriesPoint` }
`rows.kind`	`"table"`
`rows.row`	`SeriesPoint`
`coverage`	{ `kind`: `"table"` ; `row`: `SeriesCoverage` }
`coverage.kind`	`"table"`
`coverage.row`	`SeriesCoverage`
`source`	{ `kind`: `"one"` ; `row`: `SeriesOutputManifest` }
`source.kind`	`"one"`
`source.row`	`SeriesOutputManifest`

SeriesPopulationRequest

Ƭ SeriesPopulationRequest: Request<RelationalOutputs<SeriesPopulationOutputs>>

SeriesPopulationCapture

Ƭ SeriesPopulationCapture: (runs: Pick<RunClient<any>, "capturePlan">, interval: SeriesInterval, bounds: RunBounds, options: CaptureOptions) => Promise<SeriesPopulationRequest>

Type declaration

▸ (runs, interval, bounds, options): Promise<SeriesPopulationRequest> Not exported: an exported type refers to it.

Parameters

Name	Type
`runs`	`Pick`<`RunClient`<`any`>, `"capturePlan"`>
`interval`	`SeriesInterval`
`bounds`	`RunBounds`
`options`	`CaptureOptions`

Returns

Promise<SeriesPopulationRequest>

DeclaredSignalPolicy

Ƭ DeclaredSignalPolicy: Object

Type declaration

Name	Type
`method`	`"previous"` \| `"next"` \| `"nearest"` \| `"linear"`
`maxGap`	`Duration` \| `string`

SeriesPropertyCaptureGuard

Ƭ SeriesPropertyCaptureGuard: Object A semantic object binding. Captures re-read the property under current authority; this description grants neither data access nor custody.

Type declaration

Name	Type
`origin`	{ `collection`: `string` ; `id`: `string` ; `property`: `string` ; `definition`: `string` ; `property_revision`: `string` ; `is_derived`: `boolean` }
`origin.collection`	`string`
`origin.id`	`string`
`origin.property`	`string`
`origin.definition`	`string`
`origin.property_revision`	`string`
`origin.is_derived`	`boolean`
`inputs`	`Record`<`string`, { `table`: `string` ; `series`: `string` ; `version?`: `string` }>
`port`	`string`
`measure`	`string`

SeriesPropertyCaptureInput

Ƭ SeriesPropertyCaptureInput: Object

Type declaration

Name	Type
`kind`	`"native"` \| `"virtual"`
`table`	`string`
`series`	`string`
`version`	`string` \| `null`
`measure`	`string`
`schema`	`SeriesOutputManifest`[`"schema"`]
`interval`	{ `from`: `Instant` ; `to`: `Instant` }
`interval.from`	`Instant`
`interval.to`	`Instant`
`guard`	`SeriesPropertyCaptureGuard`

SeriesPropertyCapturePlan

Ƭ SeriesPropertyCapturePlan: Object The admitted formula with scalar input ports and compiler-derived causal intervals. Source versions and result basis are fixed by subsequent captures.

Type declaration

Name	Type
`format`	`"bijection.series-property-plan/v1"`
`origin`	`SeriesPropertyCaptureGuard`[`"origin"`]
`definition_digest`	`string`
`expression`	{ `node`: `SeriesExpressionNode` ; `output`: `SeriesExpressionOutput` ; `max_gap`: `string` \| `null` ; `shift`: `string` \| `null` }
`expression.node`	`SeriesExpressionNode`
`expression.output`	`SeriesExpressionOutput`
`expression.max_gap`	`string` \| `null`
`expression.shift`	`string` \| `null`
`catalog`	`unknown`
`inputs`	`Record`<`string`, `SeriesPropertyCaptureInput`>
`interval`	{ `from`: `Instant` ; `to`: `Instant` }
`interval.from`	`Instant`
`interval.to`	`Instant`

SeriesObservation

Ƭ SeriesObservation<Subject, Value>: Object Resolved scalar observations. Values use the declaration’s unit and its exact int64 or binary64 carrier. This is a sample population, not an interpolated signal.

Type parameters

Name	Type
`Subject`	`string`
`Value`	`bigint`

Type declaration

Name	Type
`subject`	`Subject`
`time_us`	`Instant`
`source_order`	`bigint`
`value`	`Value`
`unit`	`string`

SeriesCarrier

Ƭ SeriesCarrier: "int64" | "float64" The numeric representation of a series relation’s values.

RawObservation

Ƭ RawObservation<Subject, Value>: Omit<SeriesObservation<Subject, Value>, "value"> & { value: Value | null } Not exported: an exported type refers to it.

Type parameters

Name	Type
`Subject`	`Subject`
`Value`	`bigint`

SeriesRelationType

Ƭ SeriesRelationType<T, Row, Args>: Object

Type parameters

Name	Type
`T`	`T`
`Row`	`SeriesObservation`
`Args`	extends `string` = `never`

Type declaration

Name	Type
`row`	`Row`
`identity`	`unknown`
`args`	`RelationArgumentNames`<`T`> \| `Args`
`problems`	`"This operator belongs to relational pipelines"` \| `T` extends { `problems`: infer P } ? `P` : `never`
`tables`	`T` extends { `tables`: infer N } ? `N` : `never`
`scan`	`never`
`ordered`	`false`

TemporalReduction

Ƭ TemporalReduction<Value>: { status: "ready" ; value: Value ; covered_us: Duration ; requested_us: Duration } | { status: "insufficient_data" ; value: null ; covered_us: Duration ; requested_us: Duration } A sample-slot reduction keeps absence distinct from a numeric zero.

Type parameters

Name
`Value`

SeriesReduction

Ƭ SeriesReduction: "count" | "min" | "max" | "sum" | "mean"

SeriesResultMetadata

Ƭ SeriesResultMetadata: Omit<SeriesResultDescriptor, "basis"> & { basis: ComputationBasis }

SeriesData

Ƭ SeriesData<Result>: Result extends { coverage: unknown } ? Omit<Result, "basis" | "coverage"> : Result extends { value: infer Data ; evidence: unknown ; basis: string } ? Data : Omit<Result, "basis_id" | "roots"> Application payload, independent of the executor’s answer envelope.

Type parameters

Name
`Result`

SeriesEvidence

Ƭ SeriesEvidence<Result>: Result extends { coverage: infer Coverage } ? { coverage: Coverage ; settlement: Coverage extends { evidence: { settlement: infer Settlement } } ? Settlement : never } : Result extends { evidence: infer Evidence } ? Evidence : Result extends { roots: infer Roots } ? { roots: Roots } : never Evidence remains specific to the selected operator.

Type parameters

Name
`Result`

SeriesCoverageEvidence

Ƭ SeriesCoverageEvidence: Object Common evidence for one evaluated series scope.

Type declaration

Name	Type
`coverage`	`SeriesCoverage`
`settlement`	`SeriesCoverage`[`"evidence"`][`"settlement"`]

SeriesEvaluation

Ƭ SeriesEvaluation<Data, Evidence>: Object One evaluated answer; physical execution does not enter its basis.

Type parameters

Name	Type
`Data`	`Data`
`Evidence`	`SeriesCoverageEvidence`

Type declaration

Name	Type
`metadata`	`SeriesResultMetadata` \| `null`
`data`	`Data`
`basis`	`string`
`evidence`	`Evidence`

SeriesEvaluationOf

Ƭ SeriesEvaluationOf<Result>: SeriesEvaluation<SeriesData<Result>, SeriesEvidence<Result>> The authored envelope of an operator’s native answer type.

Type parameters

Name
`Result`

SeriesResultProblem

Ƭ SeriesResultProblem: Object A current disclosure observation, never a replacement execution.

Type declaration

Name	Type
`kind`	`"resultUnavailable"`
`reason`	`"notFound"` \| `"expired"` \| `"erased"` \| `"retracted"` \| `"notProduced"` \| `"unknown"`
`message`	`string`
`cause?`	`Failure`

SeriesResult

Ƭ SeriesResult<Data, Run, Evidence>: { kind: "pending" ; run: Run ; execution?: { completedRoots: number ; totalRoots: number } } | { kind: "available" ; run: Run ; question?: { kind: SeriesAnalysisKind ; options: SeriesAnalysisOptions ; measure: string | null } } & SeriesEvaluation<Data, Evidence> | { kind: "unavailable" ; run: Run ; problem: SeriesProblem | SeriesResultProblem } Execution progress is observed separately through progress.

Type parameters

Name	Type
`Data`	`Data`
`Run`	`string`
`Evidence`	`SeriesCoverageEvidence`

SeriesPagedResult

Ƭ SeriesPagedResult<Run>: Object A sealed trajectory manifest; data is read explicitly through resultPage.

Type parameters

Name	Type
`Run`	`string`

Type declaration

Name	Type
`metadata`	`SeriesResultMetadata` \| `null`
`kind`	`"paged"`
`run`	`Run`
`basis`	`string`
`evidence`	`SeriesEvidence`<`SeriesTrajectory`>
`manifest`	`Omit`<`SeriesPagedTrajectoryAnalysis`, `"state"` \| `"evidence"`>

SeriesResultFor

Ƭ SeriesResultFor<Result, Run>: SeriesResult<SeriesData<Result>, Run, SeriesEvidence<Result>> | Result extends SeriesTrajectory ? SeriesPagedResult<Run> : never The result envelope inferred from an operator’s native answer.

Type parameters

Name	Type
`Result`	`Result`
`Run`	`string`

SourceRequirements

Ƭ SourceRequirements: Object Not exported: an exported type refers to it.

Type declaration

Name	Type
`completePopulation?`	`boolean`
`coherent?`	`boolean`
`completeVersion?`	`boolean`
`completeContinuity?`	`boolean`
`maxObservationAge?`	`string`
`staleAllowed?`	`boolean`
`observedAfter?`	`string`
`evidence?`	`EvidenceClass`

SpatialOperand

Ƭ SpatialOperand<T>: ExpressionOrValue<T> | ArgumentReference<string> Not exported: an exported type refers to it.

Type parameters

Name	Type
`T`	extends `Value` \| `undefined`

SpatialRow

Ƭ SpatialRow<Document>: { [Field in keyof Document]-?: Document[Field] extends Value | undefined ? SpatialExpression<Document[Field]> : never }

Type parameters

Name
`Document`

Region

Ƭ Region: SpatialOperand<Geometry<S> | Box | null | undefined> Not exported: an exported type refers to it.

Center

Ƭ Center: SpatialOperand<Position | Extract<Geometry<S>, { type: "Point" }> | null | undefined> Not exported: an exported type refers to it.

UnboundSpatialPartition

Ƭ UnboundSpatialPartition<Field>: Object The next partition equality a range has not bound. Type-level only.

Type parameters

Name	Type
`Field`	extends `string`

Type declaration

Name	Type
`__unboundSpatialPartition?`	`Field`

SpatialRangeBuilder

Ƭ SpatialRangeBuilder<Document, Partitions, Field>: number extends Partitions["length"] ? SpatialRestrictionBuilder<Document, Field> & { eq: (field: string, value: Value) => SpatialRangeBuilder<Document, Partitions, Field> } : Partitions extends readonly [infer Head, …(infer Tail extends string[])] ? SpatialRange & UnboundSpatialPartition<Head> & { eq: (field: Head, value: FieldTypeFromFieldPath<Document, Head>) => SpatialRangeBuilder<Document, Tail, Field> } : SpatialRestrictionBuilder<Document, Field> Bind the next partition equality. Every prefix is a readable range; spatial restrictions follow the complete partition.

Type parameters

Name	Type
`Document`	extends `GenericDocument`
`Partitions`	extends readonly `string`[]
`Field`	extends `string`

Inputs

Ƭ Inputs: Record<string, JSONValue> Not exported: an exported type refers to it.

Dimension

Ƭ Dimension<U>: U extends { dimension: infer D } ? D : U extends "V" | "mV" | "kV" ? "voltage" : U extends "A" | "mA" ? "current" : U extends "W" | "kW" | "MW" ? "power" : U extends "J" | "Wh" | "kWh" ? "energy" : U extends "m" | "km" | "ft" | "mi" ? "length" : U extends "m/s" | "km/h" | "mph" | "kn" ? "speed" : U extends "Pa" | "kPa" | "bar" | "psi" ? "pressure" : U extends "°C" | "°F" | "K" ? "temperature" : U extends "us" | "ms" | "s" | "min" | "h" ? "time" : U extends "delta:°C" | "delta:°F" | "delta:K" ? "temperature_difference" : U extends "1" | "ppm" ? "dimensionless" : "unknown" Not exported: an exported type refers to it.

Type parameters

Name
`U`

Delta

Ƭ Delta<D>: D extends "temperature" ? "temperature_difference" : D Not exported: an exported type refers to it.

Type parameters

Name	Type
`D`	extends `string`

Product

Ƭ Product<L, R>: L extends "unknown" ? "unknown" : R extends "unknown" ? "unknown" : L extends "dimensionless" ? R : R extends "dimensionless" ? L : [L, R] extends ["voltage", "current"] | ["current", "voltage"] ? "power" : [L, R] extends ["power", "time"] | ["time", "power"] ? "energy" : `

\{L}*

{R}` Not exported: an exported type refers to it.

Type parameters

Name	Type
`L`	extends `string`
`R`	extends `string`

Quotient

Ƭ Quotient<L, R>: L extends "unknown" ? "unknown" : R extends "unknown" ? "unknown" : L extends R ? "dimensionless" : R extends "dimensionless" ? L : [L, R] extends ["energy", "time"] ? "power" : [L, R] extends ["power", "current"] ? "voltage" : [L, R] extends ["power", "voltage"] ? "current" : [L, R] extends ["length", "time"] ? "speed" : `

\{L}/

{R}` Not exported: an exported type refers to it.

Type parameters

Name	Type
`L`	extends `string`
`R`	extends `string`

AggregateDimension

Ƭ AggregateDimension<D, A>: A extends "count" | "relative_difference" ? "dimensionless" : A extends "product" ? D extends "dimensionless" ? D : "unknown" : A extends "difference" | "stddev" ? Delta<D> : D Not exported: an exported type refers to it.

Type parameters

Name	Type
`D`	extends `string`
`A`	extends `SeriesAggregate`

TemporalIntegralUnit

Ƭ TemporalIntegralUnit<Unit>: Dimension<Unit> extends "unknown" ? SeriesUnit : { [U in SeriesUnit]: Dimension<U> extends Product<Dimension<Unit>, “time”> ? U : never }[SeriesUnit] Named units compatible with a time integral of the admitted input unit. Unknown units remain subject to native schema validation.

Type parameters

Name
`Unit`

Scalar

Ƭ Scalar: number | bigint | string Not exported: an exported type refers to it.

Threshold

Ƭ Threshold<D>: Scalar | TemporalQuantity<SeriesUnit & D extends "unknown" ? unknown : { [U in SeriesUnit]: Dimension<U> extends D ? U : never }[SeriesUnit]> Not exported: an exported type refers to it.

Type parameters

Name	Type
`D`	extends `string`

GraphValue

Ƭ GraphValue<K>: K extends "intervals" ? TemporalIntervals : K extends "continuous_condition" ? TemporalConditions<true> : K extends "condition" ? TemporalConditions<false> : K extends "signal" ? TemporalSignals : TemporalNumbers Not exported: an exported type refers to it.

Type parameters

Name	Type
`K`	extends `TemporalGraphKind`

LogicalExtent

Ƭ LogicalExtent: Infer<typeof logicalExtent>

TemporalGraphKind

Ƭ TemporalGraphKind: "number" | "signal" | "condition" | "continuous_condition" | "intervals" The kind exposed by an admitted graph port or output.

References

Ƭ References<N>: N extends { op: "measure" } ? { op: "input" ; port: string } : Omit<N, "input" | "left" | "right" | "until" | "inputs" | "condition" | "when_true" | "when_false"> & N extends { input: unknown } ? { input: string } : unknown & N extends { left: unknown } ? { left: string ; right: string } : unknown & N extends { until: unknown } ? { until: string } : unknown & N extends { inputs: unknown } ? { inputs: string[] } : unknown & N extends { condition: unknown } ? { condition: string } : unknown & N extends { when_true: unknown } ? { when_true: string ; when_false: string } : unknown Not exported: an exported type refers to it.

Type parameters

Name
`N`

TemporalGraphNode

Ƭ TemporalGraphNode: { id: string } & References<SeriesExpressionNode> Nodes refer to other nodes by identity; executable callbacks are absent.

TemporalGraph

Ƭ TemporalGraph<K>: Object Not exported: an exported type refers to it.

Type parameters

Name	Type
`K`	extends `TemporalGraphKind` = `TemporalGraphKind`

Type declaration

Name	Type
`version`	`1`
`inputs`	`Record`<`string`, { `kind`: `TemporalGraphKind` ; `property?`: `string` }>
`nodes`	`TemporalGraphNode`[]
`output`	{ `node`: `string` ; `kind`: `K` ; `min_duration?`: `string` }
`output.node`	`string`
`output.kind`	`K`
`output.min_duration?`	`string`
`max_gap?`	`string`
`layout?`	{ `nodes`: `Record`<`string`, { `x`: `number` ; `y`: `number` }> }
`layout.nodes`	`Record`<`string`, { `x`: `number` ; `y`: `number` }>

Rows

Ƭ Rows: Object Not exported: an exported type refers to it.

Type declaration

Name	Type
`trajectory`	`TrajectoryRow`
`visits`	`VisitRow`
`dwell`	`DwellRow`

TrajectoryRequest

Ƭ TrajectoryRequest<Kind>: Omit<TrajectoryEvaluation, "kind" | "trajectory" | "region"> & { kind: Kind ; trajectory: SeriesTrajectory ; region?: Geometry | Box }

Type parameters

Name	Type
`Kind`	extends keyof `Rows` = keyof `Rows`

CursorUnknownReason

CursorEstimate

Ƭ CursorEstimate<T>: { state: "known" ; method: "observed" | Exclude<InterpolationMode, "none"> ; value: T ; before: number | null ; after: number | null ; fraction: number | null } | { state: "unknown" ; reason: CursorUnknownReason }

Type parameters

Name
`T`

SeenFileShape

Ƭ SeenFileShape<T, Seen>: Seen extends readonly [infer Head, …(infer Tail)] ? <Value>() => Value extends T ? 1 : 2 extends <Value>() => Value extends Head ? 1 : 2 ? true : SeenFileShape<T, Tail> : false Not exported: an exported type refers to it.

Type parameters

Name	Type
`T`	`T`
`Seen`	extends readonly `unknown`[]

HoldsFile

Ƭ HoldsFile<T, Seen>: T extends object ? T extends FileRef ? true : SeenFileShape<T, Seen> extends true ? false : T extends readonly infer Item[] ? HoldsFile<Item, […Seen, T]> : true extends { [Key in keyof T]-?: HoldsFile<T[Key], […Seen, T]> }[keyof T] ? true : false : false Not exported: an exported type refers to it.

Type parameters

Name	Type
`T`	`T`
`Seen`	extends readonly `unknown`[] = []

InputLimits

Ƭ InputLimits<Document>: { [Key in keyof Document as true extends HoldsFile<NonNullable<Document[Key]>> ? Key : never]-?: FileInputLimits } Not exported: an exported type refers to it.

Type parameters

Name
`Document`

RelationArgumentNames

Ƭ RelationArgumentNames<T>: T extends { args: infer A } ? A : string Not exported: an exported type refers to it.

Type parameters

Name
`T`

Source

Ƭ Source: SourceHandle<any> | VirtualDataset<any> | CapturedVirtualTable<any> Not exported: an exported type refers to it.

VirtualSeriesSource

Ƭ VirtualSeriesSource: Source Not exported: an exported type refers to it.

SourceRow

Ƭ SourceRow<S>: S extends VirtualDataset<infer Row> ? Row : S extends SourceHandle<infer Fields> ? ObjectType<Fields> : S extends CapturedVirtualTable<infer Fields> ? ObjectType<Fields> : never Not exported: an exported type refers to it.

Type parameters

Name
`S`

Execution

Ƭ Execution<S>: S extends CapturedVirtualTable<any, infer Engine> ? { executor: RelationalExecutor<Engine | undefined> } : { executor?: never } Not exported: an exported type refers to it.

Type parameters

Name
`S`

KeyValue

Ƭ KeyValue<Row, Key>: Pick<Row, Key[number]> Not exported: an exported type refers to it.

Type parameters

Name	Type
`Row`	`Row`
`Key`	extends `SeriesKeys`<`Row`>

MeasureValue

Ƭ MeasureValue<Row, M, Name>: M[Name] extends { field: infer F } ? NonNullable<Row[F]> extends number ? number : bigint : never Not exported: an exported type refers to it.

Type parameters

Name	Type
`Row`	`Row`
`M`	`M`
`Name`	extends keyof `M`

GeometryIn

Ƭ GeometryIn<S>: Object Not exported: an exported type refers to it.

Type parameters

Name
`S`

Type declaration

Name	Type
`[geometrySpace]?`	`S`

Properties

ref

• Readonly ref: RequestRef Not exported: an exported type refers to it.

Variables

temporalWindow

• Const temporalWindow: VObject<{ subject: string ; from_us: bigint ; to_us: bigint ; timeline: string ; finality: "available" | "settled" }, { subject: VString<string, "required"> ; timeline: VString<string, "required"> ; from_us: VInt64<bigint, "required"> ; to_us: VInt64<bigint, "required"> ; finality: VUnion<"available" | "settled", [VLiteral<"available", "required">, VLiteral<"settled", "required">], "required", never> }, "required", "subject" | "from_us" | "to_us" | "timeline" | "finality"> A temporal boundary’s window on one subject’s timeline: the identity’s origin from_us and the cut to_us, both aligned to the graph’s step. A boundary closes every step from its checkpoint (the first boundary, from the origin) through the cut, reading input at the declared finality.

seriesDefinition

• Const seriesDefinition: typeof seriesDefinition

seriesExpr

• Const seriesExpr: Object Builds series expressions. Every expression reads one declared measure.

Type declaration

Name	Type
`category`	(`field`: `string`) => `SeriesCategories`
`measure`	(`name`: `string`, `of?`: { `series`: `string` ; `property?`: `never` } \| { `property`: `string` ; `series?`: `never` }) => `SeriesNumbers`
`fromNode`	(`node`: `SeriesExpressionNode`) => `SeriesNumbers` \| `SeriesCondition`

geo

• Const geo: Object Spatial values, expressions and native calculations. Distances and radii are meters. The call site shows which one it makes:

constructors (geo.point, geo.circle, geo.box, geo.position) validate and return values;
geo.expr.* builds expressions for query filters, spatial reads and geo.evaluate — an expression object is never a boolean;
geo.evaluate(expression) and geo.calculate.* do native work now, under the same declared space and work allowance as database predicates.

Type declaration

Name	Type	Description
`box`	(`box`: `Box`) => `Box`	-
`circle`	(`circle`: `Circle`) => `Circle`	-
`point`	(`__namedParameters`: { `longitude`: `number` ; `latitude`: `number` }) => `Point`	-
`position`	(`position`: `Position`) => `Position`	-
`evaluate`	<T>(`expression`: `SpatialExpression`<`T`>) => `T`	Evaluate a spatial value expression in the native runtime. Components use the same declared space and work limits as database predicates.
`expr`	{ `intersects`: <Left, Right>(`left`: `Left`, `right`: `Right`) => `SpatialExpression`<`boolean`, `ScalarArgumentNames`<`Left` \| `Right`>> ; `equals`: <Left, Right>(`left`: `Left`, `right`: `Right`) => `SpatialExpression`<`boolean`, `ScalarArgumentNames`<`Left` \| `Right`>> ; `disjoint`: <Left, Right>(`left`: `Left`, `right`: `Right`) => `SpatialExpression`<`boolean`, `ScalarArgumentNames`<`Left` \| `Right`>> ; `coveredBy`: <Left, Right>(`left`: `Left`, `right`: `Right`) => `SpatialExpression`<`boolean`, `ScalarArgumentNames`<`Left` \| `Right`>> ; `covers`: <Left, Right>(`left`: `Left`, `right`: `Right`) => `SpatialExpression`<`boolean`, `ScalarArgumentNames`<`Left` \| `Right`>> ; `contains`: <Left, Right>(`left`: `Left`, `right`: `Right`) => `SpatialExpression`<`boolean`, `ScalarArgumentNames`<`Left` \| `Right`>> ; `within`: <Left, Right>(`left`: `Left`, `right`: `Right`) => `SpatialExpression`<`boolean`, `ScalarArgumentNames`<`Left` \| `Right`>> ; `touches`: <Left, Right>(`left`: `Left`, `right`: `Right`) => `SpatialExpression`<`boolean`, `ScalarArgumentNames`<`Left` \| `Right`>> ; `crosses`: <Left, Right>(`left`: `Left`, `right`: `Right`) => `SpatialExpression`<`boolean`, `ScalarArgumentNames`<`Left` \| `Right`>> ; `overlaps`: <Left, Right>(`left`: `Left`, `right`: `Right`) => `SpatialExpression`<`boolean`, `ScalarArgumentNames`<`Left` \| `Right`>> ; `distance`: <Left, Right>(`left`: `Left`, `right`: `Right`) => `SpatialExpression`<`null` \| `number`, `ScalarArgumentNames`<`Left` \| `Right`>> ; `withinDistance`: <Left, Right>(`left`: `Left`, `right`: `Right`, `distance_m`: `number`) => `SpatialExpression`<`boolean`, `ScalarArgumentNames`<`Left` \| `Right`>> ; `centerDistance`: <Left, Right>(`left`: `Left`, `right`: `Right`) => `SpatialExpression`<`null` \| `number`, `ScalarArgumentNames`<`Left` \| `Right`>> ; `classify`: <P, A>(`position`: `P`, `area`: `A`) => `SpatialExpression`<`SpatialClassification`, `ScalarArgumentNames`<`P` \| `A`>> ; `isUnknown`: <V>(`value`: `V`) => `SpatialExpression`<`boolean`, `ScalarArgumentNames`<`V`>> ; `in`: <S>(`space`: `S`) => { `intersects`: <Left, Right>(`left`: `Left`, `right`: `Right`) => `SpatialExpression`<`boolean`, `ScalarArgumentNames`<`Left` \| `Right`>> ; `equals`: <Left, Right>(`left`: `Left`, `right`: `Right`) => `SpatialExpression`<`boolean`, `ScalarArgumentNames`<`Left` \| `Right`>> ; `disjoint`: <Left, Right>(`left`: `Left`, `right`: `Right`) => `SpatialExpression`<`boolean`, `ScalarArgumentNames`<`Left` \| `Right`>> ; `coveredBy`: <Left, Right>(`left`: `Left`, `right`: `Right`) => `SpatialExpression`<`boolean`, `ScalarArgumentNames`<`Left` \| `Right`>> ; `covers`: <Left, Right>(`left`: `Left`, `right`: `Right`) => `SpatialExpression`<`boolean`, `ScalarArgumentNames`<`Left` \| `Right`>> ; `contains`: <Left, Right>(`left`: `Left`, `right`: `Right`) => `SpatialExpression`<`boolean`, `ScalarArgumentNames`<`Left` \| `Right`>> ; `within`: <Left, Right>(`left`: `Left`, `right`: `Right`) => `SpatialExpression`<`boolean`, `ScalarArgumentNames`<`Left` \| `Right`>> ; `touches`: <Left, Right>(`left`: `Left`, `right`: `Right`) => `SpatialExpression`<`boolean`, `ScalarArgumentNames`<`Left` \| `Right`>> ; `crosses`: <Left, Right>(`left`: `Left`, `right`: `Right`) => `SpatialExpression`<`boolean`, `ScalarArgumentNames`<`Left` \| `Right`>> ; `overlaps`: <Left, Right>(`left`: `Left`, `right`: `Right`) => `SpatialExpression`<`boolean`, `ScalarArgumentNames`<`Left` \| `Right`>> ; `distance`: <Left, Right>(`left`: `Left`, `right`: `Right`) => `SpatialExpression`<`null` \| `number`, `ScalarArgumentNames`<`Left` \| `Right`>> ; `withinDistance`: <Left, Right>(`left`: `Left`, `right`: `Right`, `distance_m`: `number`) => `SpatialExpression`<`boolean`, `ScalarArgumentNames`<`Left` \| `Right`>> ; `centerDistance`: <Left, Right>(`left`: `Left`, `right`: `Right`) => `SpatialExpression`<`null` \| `number`, `ScalarArgumentNames`<`Left` \| `Right`>> ; `classify`: <P, A>(`position`: `P`, `area`: `A`) => `SpatialExpression`<`SpatialClassification`, `ScalarArgumentNames`<`P` \| `A`>> ; `isUnknown`: <V>(`value`: `V`) => `SpatialExpression`<`boolean`, `ScalarArgumentNames`<`V`>> } = expressions }	Expressions in WGS84 longitude, latitude; `geo.expr.in(space)` builds them in another declared coordinate space.
`expr.intersects`	<Left, Right>(`left`: `Left`, `right`: `Right`) => `SpatialExpression`<`boolean`, `ScalarArgumentNames`<`Left` \| `Right`>>	-
`expr.equals`	<Left, Right>(`left`: `Left`, `right`: `Right`) => `SpatialExpression`<`boolean`, `ScalarArgumentNames`<`Left` \| `Right`>>	-
`expr.disjoint`	<Left, Right>(`left`: `Left`, `right`: `Right`) => `SpatialExpression`<`boolean`, `ScalarArgumentNames`<`Left` \| `Right`>>	-
`expr.coveredBy`	<Left, Right>(`left`: `Left`, `right`: `Right`) => `SpatialExpression`<`boolean`, `ScalarArgumentNames`<`Left` \| `Right`>>	-
`expr.covers`	<Left, Right>(`left`: `Left`, `right`: `Right`) => `SpatialExpression`<`boolean`, `ScalarArgumentNames`<`Left` \| `Right`>>	-
`expr.contains`	<Left, Right>(`left`: `Left`, `right`: `Right`) => `SpatialExpression`<`boolean`, `ScalarArgumentNames`<`Left` \| `Right`>>	-
`expr.within`	<Left, Right>(`left`: `Left`, `right`: `Right`) => `SpatialExpression`<`boolean`, `ScalarArgumentNames`<`Left` \| `Right`>>	-
`expr.touches`	<Left, Right>(`left`: `Left`, `right`: `Right`) => `SpatialExpression`<`boolean`, `ScalarArgumentNames`<`Left` \| `Right`>>	-
`expr.crosses`	<Left, Right>(`left`: `Left`, `right`: `Right`) => `SpatialExpression`<`boolean`, `ScalarArgumentNames`<`Left` \| `Right`>>	-
`expr.overlaps`	<Left, Right>(`left`: `Left`, `right`: `Right`) => `SpatialExpression`<`boolean`, `ScalarArgumentNames`<`Left` \| `Right`>>	-
`expr.distance`	[object Object]	-
`expr.withinDistance`	[object Object]	Missing geometry returns false; exact refinement governs index candidates.
`expr.centerDistance`	[object Object]	Symmetric distance between reported centres, independently of accuracy.
`expr.classify`	[object Object]	-
`expr.isUnknown`	[object Object]	Reported accuracy and history completeness remain independent.
`expr.in`	<S>(`space`: `S`) => { `intersects`: <Left, Right>(`left`: `Left`, `right`: `Right`) => `SpatialExpression`<`boolean`, `ScalarArgumentNames`<`Left` \| `Right`>> ; `equals`: <Left, Right>(`left`: `Left`, `right`: `Right`) => `SpatialExpression`<`boolean`, `ScalarArgumentNames`<`Left` \| `Right`>> ; `disjoint`: <Left, Right>(`left`: `Left`, `right`: `Right`) => `SpatialExpression`<`boolean`, `ScalarArgumentNames`<`Left` \| `Right`>> ; `coveredBy`: <Left, Right>(`left`: `Left`, `right`: `Right`) => `SpatialExpression`<`boolean`, `ScalarArgumentNames`<`Left` \| `Right`>> ; `covers`: <Left, Right>(`left`: `Left`, `right`: `Right`) => `SpatialExpression`<`boolean`, `ScalarArgumentNames`<`Left` \| `Right`>> ; `contains`: <Left, Right>(`left`: `Left`, `right`: `Right`) => `SpatialExpression`<`boolean`, `ScalarArgumentNames`<`Left` \| `Right`>> ; `within`: <Left, Right>(`left`: `Left`, `right`: `Right`) => `SpatialExpression`<`boolean`, `ScalarArgumentNames`<`Left` \| `Right`>> ; `touches`: <Left, Right>(`left`: `Left`, `right`: `Right`) => `SpatialExpression`<`boolean`, `ScalarArgumentNames`<`Left` \| `Right`>> ; `crosses`: <Left, Right>(`left`: `Left`, `right`: `Right`) => `SpatialExpression`<`boolean`, `ScalarArgumentNames`<`Left` \| `Right`>> ; `overlaps`: <Left, Right>(`left`: `Left`, `right`: `Right`) => `SpatialExpression`<`boolean`, `ScalarArgumentNames`<`Left` \| `Right`>> ; `distance`: <Left, Right>(`left`: `Left`, `right`: `Right`) => `SpatialExpression`<`null` \| `number`, `ScalarArgumentNames`<`Left` \| `Right`>> ; `withinDistance`: <Left, Right>(`left`: `Left`, `right`: `Right`, `distance_m`: `number`) => `SpatialExpression`<`boolean`, `ScalarArgumentNames`<`Left` \| `Right`>> ; `centerDistance`: <Left, Right>(`left`: `Left`, `right`: `Right`) => `SpatialExpression`<`null` \| `number`, `ScalarArgumentNames`<`Left` \| `Right`>> ; `classify`: <P, A>(`position`: `P`, `area`: `A`) => `SpatialExpression`<`SpatialClassification`, `ScalarArgumentNames`<`P` \| `A`>> ; `isUnknown`: <V>(`value`: `V`) => `SpatialExpression`<`boolean`, `ScalarArgumentNames`<`V`>> }	Expressions in one declared coordinate space. The operator wire retains the complete meaning; index selection cannot change it.
`calculate`	{ `trajectoryEncounterCandidates`: (`motions`: readonly { `group`: `string` ; `path`: `TimedTrajectory` }[], `metric`: `TrajectoryEncounterMetric`) => [`number`, `number`][] ; `trajectoryEncounters`: (`pairs`: readonly { `left`: `TimedTrajectory` ; `right`: `TimedTrajectory` }[], `metric`: `TrajectoryEncounterMetric`) => `TrajectoryEncounterIntervals`[] ; `trajectoryIntervals`: (`segments`: readonly { `start`: `Point` ; `end`: `Point` }[], `area`: `Geometry` \| `Box`) => `TrajectoryInterval`[][] }	Immediate native trajectory calculations.
`calculate.trajectoryEncounterCandidates`	[object Object]	Conservative encounter pairs from one native packed spatial index and exact microsecond time hulls. Returns unique ascending input-index pairs across different groups, at most 4000; native exhaustion refuses the whole set. Candidates still require trajectoryEncounters refinement.
`calculate.trajectoryEncounters`	[object Object]	Continuous centre separation under the declared projected or spherical metric. Both follow native great elliptic arc motion. Great-circle critical points use bounded analytic isolation, with a 2^-42 overlap-fraction precision. Fractions preserve exact overlap anchors and tangent contacts. Native work is cumulative across predicates and calls; at most 4000 pairs per call.
`calculate.trajectoryIntervals`	[object Object]	Intersect up to 4000 native trajectory segments with one region. Returns one interval array per input segment, in order. An empty batch still validates the region. This is an immediate native calculation in a query or mutation, sharing the same prepared topology and work allowance as spatial predicates.

temporal

• Const temporal: Object Build a formula from a typed property of the current ontology row.

Type declaration

Name	Type
`from`	<V>(`property`: `FieldReference`<`HeldCategorySeriesRef`<`V`>>) => `TemporalHeldCategories`<`V`><U>(`property`: `FieldReference`<`SignalSeriesRef`<`U`>>) => `TemporalSignals`<`Dimension`<`U`>><M, V>(`property`: `FieldReference`<`SeriesRef`<`M`, `V`, `unknown`, `"string"`>>) => `TemporalCategories`<`NonNullable`<`V`>><M, V>(`property`: `FieldReference`<`SeriesRef`<`M`, `V`, `unknown`, `"boolean"`>>) => `TemporalCategories`<`NonNullable`<`V`>>(`property`: `FieldReference`<`IntervalSeriesRef`>) => `TemporalIntervals`(`property`: `FieldReference`<`ConditionSeriesRef`<`true`>>) => `TemporalConditions`<`true`>(`property`: `FieldReference`<`ConditionSeriesRef`<`false`>>) => `TemporalConditions`<`false`>(`property`: `FieldReference`<`ConditionSeriesRef`>) => `TemporalConditions`<`boolean`><M, V, U>(`property`: `FieldReference`<`SeriesRef`<`M`, `V`, `U`>>) => `TemporalNumbers`<`Dimension`<`U`>>
`graph`	<K>(`definition`: `TemporalGraph`<`K`>, `bindings`: `object`) => `GraphValue`<`K`>
`hold`	<S, M, V, U, K>(`property`: `ViewLookup`<`"series_ref"`, `S`, `SeriesRef`<`M`, `V`, `U`, `K`>>, `options`: { `maxAge`: `bigint` \| `string` }) => `ViewLookup`<`"series_ref"`, `S`, `HeldCategorySeriesRef`<`NonNullable`<`V`>>>
`interpolate`	<S, M, V, U>(`property`: `ViewLookup`<`"series_ref"`, `S`, `SeriesRef`<`M`, `V`, `U`, `"number"`>>, `options`: { `method`: `"linear"` \| `"previous"` ; `maxGap`: `bigint` \| `string` }) => `ViewLookup`<`"series_ref"`, `S`, `SignalSeriesRef`<`U`>>
`quantity`	<U>(`value`: `string` \| `bigint`, `unit`: `U`) => `TemporalQuantity`<`U`>

logicalExtent

• Const logicalExtent: VObject<{ from: bigint ; to: bigint ; visible: { from: bigint; to: bigint; } ; boundaries: { value: string | bigint; side: “start” | “end”; path: string; }[] }, { from: VInt64<bigint, "required"> ; to: VInt64<bigint, "required"> ; visible: VObject<{ from: bigint ; to: bigint }, { from: VInt64<bigint, "required"> ; to: VInt64<bigint, "required"> }, "required", "from" | "to"> ; boundaries: VArray<{ value: string | bigint ; side: "start" | "end" ; path: string }[], VObject<{ value: string | bigint ; side: "start" | "end" ; path: string }, { side: VUnion<"start" | "end", [VLiteral<"start", "required">, VLiteral<"end", "required">], "required", never> ; path: VString<string, "required"> ; value: VUnion<string | bigint, [VInt64<bigint, "required">, VString<string, "required">], "required", never> }, "required", "value" | "side" | "path">, "required"> }, "required", "from" | "to" | "visible" | "boundaries" | "visible.from" | "visible.to">

temporalGraphOperators

Functions

acceptedSeries

▸ acceptedSeries(reader, result): Promise<AcceptedSeries> Resolve a single accepted result reference into its typed temporal view. Only the original owner’s manifest supplies row and coverage references. Opening performs an authorized metadata read and never submits computation.

Parameters

Name	Type
`reader`	`Pick`<`ResultReader`, `"read"`>
`result`	`ResultRef`<`SeriesOutputManifest`, `"artifact"`>

Returns

Promise<AcceptedSeries>

publishAcceptedSeries

▸ publishAcceptedSeries(ctx, request): Promise<SeriesWindowResult> Publish one window of an accepted series result as a native window publication, without computing anything. The result is first required through its original owner, so the publishing mutation is fenced and records the answer it relied on. The fingerprint names the exact result version, series and window; a selection is replaced only through expected_result, never silently. Name the version in target.series_id so a later result cannot replace one a plan already uses. Source restrictions and erasure of the copy remain with the result’s custody owner, which the caller registers.

Parameters

Name	Type	Description
`ctx`	`Object`	-
`ctx.results`	`Pick`<`ResultReader`, `"read"` \| `"paginate"` \| `"require"`>	-
`ctx.series`	`NativeSeriesWriter`<`any`>	-
`request`	`Object`	-
`request.result`	`ResultRef`<`SeriesOutputManifest`, `"artifact"`>	-
`request.requirements`	`ResultRequirements`	-
`request.series`	`string`	The output series within the accepted result.
`request.target`	`Object`	-
`request.target.table`	`string`	-
`request.target.series_id`	`string`	-
`request.target.source_id`	`string`	-
`request.target.field`	`string`	-
`request.from`	`bigint`	-
`request.to`	`bigint`	-
`request.is_final`	`boolean`	-

Returns

Promise<SeriesWindowResult>

temporalGraph

▸ temporalGraph(graph, declared): JobHandler<"temporal"> Run an inferred temporal graph on the installed temporal runner. Each run is one boundary: its window cut and the exact input Dataset versions, read by reference under the attempt’s grant, and it restores the previous temporalCheckpoint (with the fold state of a stateful graph, which the declared reset policy discards at reset boundaries). It replies with its output Datasets and the new checkpoint, which commit together as one publication group.

Parameters

Name	Type
`graph`	`TemporalGraph`
`declared`	`Options`

Returns

JobHandler<"temporal">

seriesModel

▸ seriesModel<Args>(action): Readonly<{ series: (options: Omit<Stage, "action" | "args"> & { args: Args }) => ModelSeries }> Adapt an ordinary model action to inert, nestable TypeScript series inputs. The action’s existing owner fixes code, arguments, exact inputs and retries.

Type parameters

Name	Type
`Args`	extends `Record`<`string`, `Value`>

Parameters

Name	Type
`action`	`FunctionReference`<`"action"`, `any`, `Args` & `ModelSeriesArguments`, `ModelSeriesOutcome`>

Returns

Readonly<{ series: (options: Omit<Stage, "action" | "args"> & { args: Args }) => ModelSeries }>

seriesExpression

▸ seriesExpression<Args>(action): Readonly<{ sampled: (options: { args: Args ; inputs: Record<string, ModelSeriesInput> ; expression: SeriesNumbers ; sampling: SeriesSampledOptions ; output: Stage["output"] }) => ModelSeries }> The shared temporal kernel’s sample-producing expression as an explicit subcomputation. The evaluator action passes inputs, expression and the requested interval to its admitted customer function, using evaluate_series_outputs and write_series_output. Its ordinary owner accepts the resulting manifest and both streams atomically.

Type parameters

Name	Type
`Args`	extends `Record`<`string`, `Value`>

Parameters

Name	Type
`action`	`FunctionReference`<`"action"`, `any`, `Args` & `ModelSeriesArguments` & { `expression`: { `node`: `SeriesExpressionNode` ; `output`: `SeriesExpressionOutput` } }, `ModelSeriesOutcome`>

Returns

Readonly<{ sampled: (options: { args: Args ; inputs: Record<string, ModelSeriesInput> ; expression: SeriesNumbers ; sampling: SeriesSampledOptions ; output: Stage["output"] }) => ModelSeries }>

seriesUploadDestination

▸ seriesUploadDestination(occurrence): SeriesUploadDestination & { occurrence: { until: string } }

Parameters

Name	Type
`occurrence`	`SeriesUploadOccurrence` & { `until`: `bigint` }

Returns

SeriesUploadDestination & { occurrence: { until: string } } ▸ seriesUploadDestination(occurrence): SeriesUploadDestination

Parameters

Name	Type
`occurrence`	`SeriesUploadOccurrence`

Returns

SeriesUploadDestination

seriesReadError

▸ seriesReadError(read): Error Convert an unavailable read into its engine failure or an ordinary error carrying the unavailable sample scope.

Parameters

Name	Type
`read`	`Exclude`<`SeriesRead`<`unknown`>, { `kind`: `"available"` }>

Returns

Error

occurrence

▸ occurrence<Fields>(fields): VObject<{ key: string ; values: Expand<{ [Property in string | number | symbol]?: Exclude<Infer<Fields[Property]>, undefined> } & { [Property in string | number | symbol]: Infer<Fields[Property]> }> ; series: string ; time: bigint ; source: string ; order: bigint ; admission: bigint ; event_id: string ; received_at: bigint ; is_late: boolean }, { series: VString<string, "required"> ; source: VString<string, "required"> ; event_id: VString<string, "required"> ; key: VString<string, "required"> ; time: VInt64<bigint, "required"> ; order: VInt64<bigint, "required"> ; received_at: VInt64<bigint, "required"> ; admission: VInt64<bigint, "required"> ; is_late: VBoolean<boolean, "required"> ; values: VObject<Expand<{ [Property in string | number | symbol]?: Exclude<Infer<Fields[Property]>, undefined> } & { [Property in string | number | symbol]: Infer<Fields[Property]> }>, Fields, "required", { [Property in string | number | symbol]: Property | `

\{Property & string}.

{Fields[Property][“fieldPaths”]}` }[keyof Fields] & string> }, "required", "key" | "values" | "series" | "time" | "source" | "order" | "admission" | "event_id" | "received_at" | "is_late" | `values.

\{\{ [Property in string \| number \| symbol]: Property \| \`

{Property & string}.${Fields[Property][“fieldPaths”]}` }[keyof Fields] & string}`> Not exported: an exported type refers to it.

Type parameters

Name	Type
`Fields`	extends `Record`<`string`, `GenericValidator`>

Parameters

Name	Type
`fields`	`Fields`

Returns

VObject<{ key: string ; values: Expand<{ [Property in string | number | symbol]?: Exclude<Infer<Fields[Property]>, undefined> } & { [Property in string | number | symbol]: Infer<Fields[Property]> }> ; series: string ; time: bigint ; source: string ; order: bigint ; admission: bigint ; event_id: string ; received_at: bigint ; is_late: boolean }, { series: VString<string, "required"> ; source: VString<string, "required"> ; event_id: VString<string, "required"> ; key: VString<string, "required"> ; time: VInt64<bigint, "required"> ; order: VInt64<bigint, "required"> ; received_at: VInt64<bigint, "required"> ; admission: VInt64<bigint, "required"> ; is_late: VBoolean<boolean, "required"> ; values: VObject<Expand<{ [Property in string | number | symbol]?: Exclude<Infer<Fields[Property]>, undefined> } & { [Property in string | number | symbol]: Infer<Fields[Property]> }>, Fields, "required", { [Property in string | number | symbol]: Property | `

\{Property & string}.

\{\{ [Property in string \| number \| symbol]: Property \| \`

{Property & string}.${Fields[Property][“fieldPaths”]}` }[keyof Fields] & string}`>

fleetEncounters

▸ fleetEncounters(fleet, options): SeriesFleetEncounters Continuous encounters over the disclosed population. Source discovery and retained execution remain with ctx.series.fleetEncounters.

Parameters

Name	Type
`fleet`	`SeriesFleetTrajectories`
`options`	`SeriesEncounterOptions`

Returns

SeriesFleetEncounters

isSeriesFailure

▸ isSeriesFailure(value): value is SeriesFailure Validate native failure data without parsing messages or granting authority.

Parameters

Name	Type
`value`	`unknown`

Returns

value is SeriesFailure

trajectoryGeoJSON

▸ trajectoryGeoJSON(trajectory): SeriesTrajectoryGeoJSON Draw a native trajectory without joining gaps, dropping lone fixes, or drawing seam crossings through Greenwich. Reported fixes keep accuracy; interpolated segments claim no accuracy. This is a rendering projection, not an entrance/dwell calculation or a current authorization check.

Parameters

Name	Type
`trajectory`	`SeriesTrajectory`

Returns

SeriesTrajectoryGeoJSON

placeSeriesFleet

▸ placeSeriesFleet<Page>(hosts): PlacedSeriesFleet<Page> Place a population beyond the native bounds on the admitted hosts. An action plans each page with a query (plan.planPage), passes it to dispatch, and continues from cursor until isDone.

Type parameters

Name	Type
`Page`	`SeriesFleetPage`<`any`, `any`>

Parameters

Name	Type
`hosts`	`SeriesFleetHosts`

Returns

PlacedSeriesFleet<Page>

trajectoryTimeToMicros

▸ trajectoryTimeToMicros(time, rounding): bigint Quantize a modeled boundary to integer microseconds, using exact integer arithmetic on its binary64 fraction. nearest ties choose the later instant. Epochs and anchor differences never pass through Number.

Parameters

Name	Type
`time`	`SeriesTrajectoryTime`
`rounding`	`TrajectoryTimeRounding`

Returns

bigint

trajectoryVisits

▸ trajectoryVisits(trajectory, area, options?): SeriesTrajectoryVisits Compute region visits and modeled dwell in a query or mutation from a native trajectory answer. Native geometry clips holes, disconnected parts, seam crossings, boundary contacts and stationary paths. Consecutive pieces join only through the same supporting native occurrence; gaps never merge. This calculation keeps the input’s basis and evidence, and does not accept new durable work or reauthorize an already disclosed value.

Parameters

Name	Type
`trajectory`	`SeriesTrajectory`
`area`	`Geometry` \| `Box`
`options`	`Object`
`options.max_visits?`	`number`

Returns

SeriesTrajectoryVisits

keyedInput

▸ keyedInput<Key, Fields>(key, fields): VObject<{ key: SeriesKeyValue<Key> ; values: Expand<{ [Property in string | number | symbol]?: Exclude<Infer<Fields[Property]>, undefined> } & { [Property in string | number | symbol]: Infer<Fields[Property]> }> ; time: bigint ; order: bigint ; event_id: string }, { key: Validator<SeriesKeyValue<Key>, "required", any> = keyValidator; event_id: VString<string, "required"> ; time: VInt64<bigint, "required"> ; order: VInt64<bigint, "required"> ; values: VObject<Expand<{ [Property in string | number | symbol]?: Exclude<Infer<Fields[Property]>, undefined> } & { [Property in string | number | symbol]: Infer<Fields[Property]> }>, Fields, "required", { [Property in string | number | symbol]: Property | `

\{Property & string}.

{Fields[Property][“fieldPaths”]}` }[keyof Fields] & string> }, "required", "key" | "values" | "time" | "order" | `key.

\{any}\` \| ``"event_id"`` \| \`values.

{{ [Property in string | number | symbol]: Property | `

\{Property & string\}.

{Fields[Property][“fieldPaths”]}` }[keyof Fields] & string}`> Not exported: an exported type refers to it.

Type parameters

Name	Type
`Key`	extends `SeriesKeyDefinition`
`Fields`	extends `Record`<`string`, `GenericValidator`>

Parameters

Name	Type
`key`	`Key`
`fields`	`Fields`

Returns

VObject<{ key: SeriesKeyValue<Key> ; values: Expand<{ [Property in string | number | symbol]?: Exclude<Infer<Fields[Property]>, undefined> } & { [Property in string | number | symbol]: Infer<Fields[Property]> }> ; time: bigint ; order: bigint ; event_id: string }, { key: Validator<SeriesKeyValue<Key>, "required", any> = keyValidator; event_id: VString<string, "required"> ; time: VInt64<bigint, "required"> ; order: VInt64<bigint, "required"> ; values: VObject<Expand<{ [Property in string | number | symbol]?: Exclude<Infer<Fields[Property]>, undefined> } & { [Property in string | number | symbol]: Infer<Fields[Property]> }>, Fields, "required", { [Property in string | number | symbol]: Property | `

\{Property & string}.

{Fields[Property][“fieldPaths”]}` }[keyof Fields] & string> }, "required", "key" | "values" | "time" | "order" | `key.

\{any}\` \| ``"event_id"`` \| \`values.

{{ [Property in string | number | symbol]: Property | `

\{Property & string\}.

{Fields[Property][“fieldPaths”]}` }[keyof Fields] & string}`>

defineSeries

▸ defineSeries<Key, Fields, Decimal, Units, Ingestion>(definition): SeriesDefinition<Fields, Key, Decimal, Units, SeriesCoordinateIndexes, Ingestion> A typed family of observations keyed by application identity.

Type parameters

Name	Type
`Key`	extends `ScalarKey` \| `Record`<`string`, `Validator`<`string` \| `bigint` \| `boolean`, `"required"`, `any`>>
`Fields`	extends `Record`<`string`, `GenericValidator`>
`Decimal`	extends `Extract`<keyof `Fields`, `string`> = `never`
`Units`	extends `Partial`<`Record`<`Extract`<keyof `Fields`, `string`>, `SeriesUnit`>> = {}
`Ingestion`	extends `"application"` \| `"source"` = `"source"`

Parameters

Name	Type
`definition`	{ `key`: `Key` ; `values`: `Fields` ; `units?`: `Units` ; `ingestion?`: { `kind`: `Ingestion` } ; `decimal?`: `Partial`<`Record`<`Decimal`, `number`>> } & `Omit`<`SeriesOptions`<`Fields`>, `"key"` \| `"units"` \| `"decimal"` \| `"ingestion"`>

Returns

SeriesDefinition<Fields, Key, Decimal, Units, SeriesCoordinateIndexes, Ingestion>

series

▸ series<S, Contract>(observation, output): Readonly<{ kind: "series" ; observation: ObservationHandle<S, "occurrences", Contract> ; output: Readonly<{ table: string ; key: FieldsOfKind<S, "string"> ; orderBy: FieldsOfKind<S, "int64"> ; settlement?: { lateness: string | bigint ; idleAfter?: string | bigint } }> = selected }>

Type parameters

Name	Type
`S`	extends `Fields`
`Contract`	`Contract`

Parameters

Name	Type
`observation`	`ObservationHandle`<`S`, `"occurrences"`, `Contract`>
`output`	`NativeSeriesOutput`<`S`>

Returns

Readonly<{ kind: "series" ; observation: ObservationHandle<S, "occurrences", Contract> ; output: Readonly<{ table: string ; key: FieldsOfKind<S, "string"> ; orderBy: FieldsOfKind<S, "int64"> ; settlement?: { lateness: string | bigint ; idleAfter?: string | bigint } }> = selected }>

defineSeriesRequests

▸ defineSeriesRequests<Args, Definition>(report): TableDefinition<VObject<{ definition: Definition ; arguments: Expand<{ [Property in string | number | symbol]?: Exclude<Infer<Args[Property]>, undefined> } & { [Property in string | number | symbol]: Infer<Args[Property]> }> ; run: string }, { arguments: VObject<Expand<{ [Property in string | number | symbol]?: Exclude<Infer<Args[Property]>, undefined> } & { [Property in string | number | symbol]: Infer<Args[Property]> }>, Args, "required", { [Property in string | number | symbol]: Property | `

\{Property & string}.

{Args[Property][“fieldPaths”]}` }[keyof Args] & string> = report.args; run: VString<string, "required"> ; definition: VLiteral<Definition, "required"> }, "required", "definition" | "arguments" | "run" | `arguments.

\{\{ [Property in string \| number \| symbol]: Property \| \`

{Property & string}.${Args[Property][“fieldPaths”]}` }[keyof Args] & string}`>, {}, {}, {}, false, {}>

Type parameters

Name	Type
`Args`	extends `PropertyValidators`
`Definition`	extends `string`

Parameters

Name	Type
`report`	`SeriesReportDefinition`<`Args`, `Definition`>

Returns

TableDefinition<VObject<{ definition: Definition ; arguments: Expand<{ [Property in string | number | symbol]?: Exclude<Infer<Args[Property]>, undefined> } & { [Property in string | number | symbol]: Infer<Args[Property]> }> ; run: string }, { arguments: VObject<Expand<{ [Property in string | number | symbol]?: Exclude<Infer<Args[Property]>, undefined> } & { [Property in string | number | symbol]: Infer<Args[Property]> }>, Args, "required", { [Property in string | number | symbol]: Property | `

\{Property & string}.

\{\{ [Property in string \| number \| symbol]: Property \| \`

{Property & string}.${Args[Property][“fieldPaths”]}` }[keyof Args] & string}`>, {}, {}, {}, false, {}>

seriesRequestAccess

▸ seriesRequestAccess<Args, Read, Create>(report, permissions): Object Explicit permissions for an immutable report request, derived from its arguments.

Type parameters

Name	Type
`Args`	extends `PropertyValidators`
`Read`	extends `string`
`Create`	extends `string`

Parameters

Name	Type
`report`	`SeriesReportDefinition`<`Args`>
`permissions`	`Object`
`permissions.read`	`Read`
`permissions.create`	`Create`

Returns

Object

Name	Type
`document`	{ `read`: `Read` = permissions.read; `create`: `Create` = permissions.create; `delete`: `false` }
`document.read`	`Read`
`document.create`	`Create`
`document.delete`	`false`
`fields`	{ `arguments`: { `read`: `Read` = permissions.read; `create`: `Create` = permissions.create; `update`: `false` ; `fields`: `ImmutableRequestFields`<`Args`, `Read`, `Create`> } ; `run`: { `read`: `Read` = permissions.read; `create`: `Create` = permissions.create; `update`: `false` } = fixed; `definition`: { `read`: `Read` = permissions.read; `create`: `Create` = permissions.create; `update`: `false` } = fixed }
`fields.arguments`	{ `read`: `Read` = permissions.read; `create`: `Create` = permissions.create; `update`: `false` ; `fields`: `ImmutableRequestFields`<`Args`, `Read`, `Create`> }
`fields.arguments.read`	`Read`
`fields.arguments.create`	`Create`
`fields.arguments.update`	`false`
`fields.arguments.fields`	`ImmutableRequestFields`<`Args`, `Read`, `Create`>
`fields.run`	{ `read`: `Read` = permissions.read; `create`: `Create` = permissions.create; `update`: `false` }
`fields.run.read`	`Read`
`fields.run.create`	`Create`
`fields.run.update`	`false`
`fields.definition`	{ `read`: `Read` = permissions.read; `create`: `Create` = permissions.create; `update`: `false` }
`fields.definition.read`	`Read`
`fields.definition.create`	`Create`
`fields.definition.update`	`false`

publishExpression

▸ publishExpression(series, request): Promise<SeriesWindowResult> Materialize one window of a numeric expression as a window-published derived series: evaluate it over [from, to) of the source series and select the result as the target window’s whole population. The target table declares publication: "window" and admits through the calling mutation; field is its numeric payload field. The fingerprint is the answer’s identity.question_id: the definition at the input’s basis identity over this window, so equal inputs name equal work in any transaction. Over a window-published source, the output is examined only where the publications of every series the expression reads completely examined its input, and final only when they are. A window with more than 2,000 output values is refused: publish smaller windows.

Parameters

Name	Type
`series`	`NativeSeriesWriter`<`any`>
`request`	`Object`
`request.source`	`Object`
`request.source.table`	`string`
`request.source.series_id`	`string`
`request.expression`	`SeriesNumbers`
`request.options?`	`SeriesExpressionOptions`
`request.target`	`Object`
`request.target.table`	`string`
`request.target.series_id`	`string`
`request.target.source_id`	`string`
`request.target.field`	`string`
`request.from`	`bigint`
`request.to`	`bigint`
`request.is_final`	`boolean`

Returns

Promise<SeriesWindowResult>

startSeriesArchive

▸ startSeriesArchive(runs, request, options?): Promise<Request<RelationalOutputs<{ rows: { kind: "table" ; row: Record<string, Value> } }>>> Ask one series expression over a series table’s pinned recovery archive, for fleet-wide or long-range questions native evaluation bounds. The supplied run client owns the original admission and recovery. Read request.outputs.rows.resolve() for the accepted rows. executor is an installed archive-capable SQL source. Each series is read under its read policy and the archive version is pinned before the statement leaves. The question is refused, never answered differently, when the archive does not yet hold the range, an erasure awaits its archive rewrite, the series resolves per key, or an operator is one only native evaluation answers; binary64 sums, means and deviations are computed by the engine only with approximate. The answer basis carries a questions map of native logical identities by series, plus floor, known_until and visible_from: the first output instant whose whole input is retained, as native coverage.visible_from. The series table declares a release rule in its access, as every retained query input does, and its archive discloses the payload (archive: { withhold: [] }).

Parameters

Name	Type
`runs`	`Pick`<`RunClient`<`any`>, `"capturePlan"`>
`request`	`Object`
`request.executor`	`SourceHandle`
`request.resources?`	`AnalyticalResources`
`request.table`	`string`
`request.seriesIds`	readonly `string`[]
`request.from`	`bigint`
`request.to`	`bigint`
`request.expression`	`SeriesNumbers` \| `SeriesCondition`
`request.output`	`SeriesArchiveOutput`
`request.options?`	`SeriesExpressionOptions`
`request.approximate?`	`boolean`
`request.maxRows?`	`number`
`request.maxBytes?`	`number`
`request.maxScannedBytesPerStatement?`	`bigint`
`request.maxProviderBilledBytesPerRun?`	`bigint`
`request.retainFor?`	`ReadDuration`
`request.timeout?`	`ReadDuration`
`options`	`CaptureOptions`

Returns

Promise<Request<RelationalOutputs<{ rows: { kind: "table" ; row: Record<string, Value> } }>>>

extractSeriesArchive

▸ extractSeriesArchive(runs, request, options?): Promise<SeriesPopulationRequest> Capture an archive’s resolved primitive population for an explicitly selected customer computation. The original run owner seals rows and coverage and synthesizes source from its own accepted result references. Pass their resolved refs as {result, rows, coverage} to seriesInput or seriesInputs; no caller-authored manifest or custody is introduced. Optional measures are refused rather than collapsing missing into null.

Parameters

Name	Type
`runs`	`Pick`<`RunClient`<`any`>, `"capturePlan"`>
`request`	`Object`
`request.executor`	`SourceHandle`
`request.resources?`	`AnalyticalResources`
`request.table`	`string`
`request.seriesIds`	readonly `string`[]
`request.measure`	`string`
`request.from`	`bigint`
`request.to`	`bigint`
`request.maxRows?`	`number`
`request.maxBytes?`	`number`
`request.maxScannedBytesPerStatement?`	`bigint`
`request.maxProviderBilledBytesPerRun?`	`bigint`
`request.retainFor?`	`ReadDuration`
`request.timeout?`	`ReadDuration`
`request.propertyGuard?`	`SeriesPropertyCaptureGuard`
`options`	`CaptureOptions`

Returns

Promise<SeriesPopulationRequest>

extractSeriesPropertyInput

▸ extractSeriesPropertyInput(runs, input, placement, options?): Promise<SeriesPopulationRequest> Capture one native input from an admitted object-property plan through its original archive owner. Its guard, source and causal scope remain together.

Parameters

Name	Type
`runs`	`Parameters`<typeof `extractSeriesArchive`>[`0`]
`input`	`SeriesPropertyCaptureInput`
`placement`	`Omit`<`Parameters`<typeof `extractSeriesArchive`>[`1`], `"table"` \| `"seriesIds"` \| `"measure"` \| `"from"` \| `"to"` \| `"propertyGuard"`>
`options`	`CaptureOptions`

Returns

Promise<SeriesPopulationRequest>

resolveSeriesCapture

▸ resolveSeriesCapture(request, options?): Promise<{ status: "ready" ; source: SeriesInputValue } | { status: "pending" ; request: typeof ref } | { status: "unavailable" ; request: typeof ref ; reason: string }> Resolve a run capture’s three original accepted references for a planned customer function. Pending work keeps its original Request; this helper never substitutes another capture or reads rows through the caller.

Parameters

Name	Type
`request`	`SeriesPopulationRequest`
`options`	`ObservationOptions`

Returns

Promise<{ status: "ready" ; source: SeriesInputValue } | { status: "pending" ; request: typeof ref } | { status: "unavailable" ; request: typeof ref ; reason: string }>

defineSeriesProperty

▸ defineSeriesProperty<T, Fields, Key, Decimal, Units, Measure, Args>(definition): SeriesRelation<SeriesRelationType<T, RelationRow<T>, Args>> Bind a retained observation relation to the native schema’s raw numeric property. Deployment verifies the measure, unit and source authority. This first profile is independent int64 samples; derived signals, interpolation and native cut equivalence require their own implemented bindings.

Type parameters

Name	Type
`T`	`T`
`Fields`	extends `Record`<`string`, `GenericValidator`>
`Key`	extends `SeriesKeyDefinition`
`Decimal`	extends `Extract`<keyof `Fields`, `string`>
`Units`	extends `Partial`<`Record`<`Extract`<keyof `Fields`, `string`>, `SeriesUnit`>>
`Measure`	extends `Extract`<keyof `Fields`, `string`>
`Args`	extends `string` = `never`

Parameters

Name	Type
`definition`	`Object`
`definition.series`	`SeriesDefinition`<`Fields`, `Key`, `Decimal`, `Units`>
`definition.input`	`Object`
`definition.input.dataset`	`string`
`definition.measure`	`Measure` & `NonNullable`<`Fields`[`Measure`][`"type"`]> extends `bigint` ? `unknown` : `never`
`definition.from`	`Relation`<`T`>
`definition.subject`	(`row`: `RowReference`<`RelationRow`<`T`>>) => `Scalar`<`string`, `Args`>
`definition.time`	(`row`: `RowReference`<`RelationRow`<`T`>>) => `Scalar`<`bigint`, `Args`>
`definition.order`	(`row`: `RowReference`<`RelationRow`<`T`>>) => `Scalar`<`bigint`, `Args`>
`definition.value`	(`row`: `RowReference`<`RelationRow`<`T`>>) => `Scalar`<`bigint` \| `null`, `Args`>

Returns

SeriesRelation<SeriesRelationType<T, RelationRow<T>, Args>>

evaluateSpatial

▸ evaluateSpatial(request, account?): boolean | number | null | SpatialClassification Pure evaluation through the shared Rust semantic kernel. No database reads, storage keys or execution authority cross this value binding.

Parameters

Name	Type
`request`	`SpatialEvaluation`
`account?`	`GeometryWorkAccount`

Returns

boolean | number | null | SpatialClassification

evaluateGeometry

▸ evaluateGeometry(request, account?): unknown

Parameters

Name	Type
`request`	`GeometryRequest`
`account?`	`GeometryWorkAccount`

Returns

unknown

publishSeries

▸ publishSeries(series, request): Promise<SeriesWindowResult> Materialize the admitted definition of a numeric object property. The target is a window-published series; native question identity, source examination and current property authority are preserved.

Parameters

Name	Type
`series`	`NativeSeriesWriter`<`any`>
`request`	`Object`
`request.source`	`DerivedSeriesRef`
`request.target`	`Object`
`request.target.table`	`string`
`request.target.series_id`	`string`
`request.target.source_id`	`string`
`request.target.field`	`string`
`request.from`	`bigint`
`request.to`	`bigint`
`request.is_final`	`boolean`

Returns

Promise<SeriesWindowResult>

temporalGraphFields

▸ temporalGraphFields(op): readonly string[] Supported controls for the visual profile. Returns a copy.

Parameters

Name	Type
`op`	`TemporalGraphNode`[`"op"`]

Returns

readonly string[]

compileTemporalGraph

▸ compileTemporalGraph<K>(graph): Object Lower a graph to the same expression used by fluent temporal.from formulas. The stable port order follows expression traversal, independent of JSON keys, node IDs, sharing and editor layout.

Type parameters

Name	Type
`K`	extends `TemporalGraphKind`

Parameters

Name	Type
`graph`	`TemporalGraph`<`K`>

Returns

Object

Name	Type
`node`	`SeriesExpressionNode`
`ports`	`string`[]
`kind`	`K`
`min_micros`	`string`
`max_gap`	`undefined` \| `string`

parseTemporalGraph

▸ parseTemporalGraph<K>(value, output): TemporalGraph<K> Admit a JSON import against an explicit output contract. The returned file profile is a detached snapshot; t.graph lowers it with row bindings.

Type parameters

Name	Type
`K`	extends `TemporalGraphKind`

Parameters

Name	Type
`value`	`unknown`
`output`	`K`

Returns

TemporalGraph<K>

evaluateTrajectory

▸ evaluateTrajectory<Kind>(request): TemporalResult<Rows[Kind]> One answer retains coverage for an empty row population. This binding reads no sources and conveys no authority over its input basis.

Type parameters

Name	Type
`Kind`	extends keyof `Rows`

Parameters

Name	Type
`request`	`TrajectoryRequest`<`Kind`>

Returns

TemporalResult<Rows[Kind]>

estimateTrajectorySamples

▸ estimateTrajectorySamples<Kind>(samples, at, options): CursorEstimate<Kind extends "position" ? [number, number] : number> Cursor evaluation over resolved samples. Sample times and the maximum gap use the same integer unit. Only the relative interpolation ratio is rounded. This function neither resolves corrections nor extends source coverage.

Type parameters

Name	Type
`Kind`	extends `CursorValueKind`

Parameters

Name	Type
`samples`	readonly { `time`: `bigint` ; `value`: `Kind` extends `"position"` ? readonly [`number`, `number`] : `number` \| `null` }[]
`at`	`bigint`
`options`	`Object`
`options.kind`	`Kind`
`options.mode`	`InterpolationMode`
`options.max_gap`	`bigint`

Returns

CursorEstimate<Kind extends "position" ? [number, number] : number>

trajectoryPosition

▸ trajectoryPosition(start, end, fraction): [number, number] A point on the native trajectory segment, a great elliptic arc. Reported endpoints retain their seam convention.

Parameters

Name	Type
`start`	[`number`, `number`]
`end`	[`number`, `number`]
`fraction`	`number`

Returns

[number, number]

trajectoryPositionAt

▸ trajectoryPositionAt(trajectory, at): SeriesTrajectoryEndpoint | null Presentation of a disclosed native path at an exact instant. Gaps and the half-open coverage remain unchanged; interpolated accuracy stays unknown.

Parameters

Name	Type
`trajectory`	`SeriesTrajectory`
`at`	`bigint`

Returns

SeriesTrajectoryEndpoint | null

defineVirtualSeries

▸ defineVirtualSeries<S, Key, M>(definition): ResolvedVirtualSeriesDefinition<SourceRow<S>, Key, M> Bind temporal meaning to an existing source owner.

Type parameters

Name	Type
`S`	extends `Source`
`Key`	extends `SeriesKeys`<`SourceRow`<`S`>>
`M`	extends `SeriesMeasures`<`SourceRow`<`S`>>

Parameters

Name	Type
`definition`	{ `source`: `S` } & `Execution`<`S`> & { `temporal`: `SeriesContract`<`SourceRow`<`S`>, `Key`, `M`, { `kind`: `"resolved"` }> }

Returns

ResolvedVirtualSeriesDefinition<SourceRow<S>, Key, M> ▸ defineVirtualSeries<S, Key, M>(definition): VirtualSeriesDefinition<SourceRow<S>, Key, M>

Type parameters

Name	Type
`S`	extends `Source`
`Key`	extends `SeriesKeys`<`SourceRow`<`S`>>
`M`	extends `SeriesMeasures`<`SourceRow`<`S`>>

Parameters

Name	Type
`definition`	{ `source`: `S` } & `Execution`<`S`> & { `temporal`: `SeriesContract`<`SourceRow`<`S`>, `Key`, `M`, `Extract`<`SeriesObservations`<`SourceRow`<`S`>>, { `kind`: `"revisable"` }>> }

Returns

VirtualSeriesDefinition<SourceRow<S>, Key, M>

​Classes

​Interfaces

​References

​resultRepresentationInput

​ResultSpatialCell

​ResultSpatialFeature

​ResultSpatialPlan

​ResultSpatialRepresentation

​Type Aliases

​ReadonlyAccessField

​Type declaration

​CheckedAccessBinding

​Type parameters

​Options

​Type declaration

​FieldsOfKind

​Type parameters

​LiveMediaOptions

​Type declaration

​LiveMediaTicket

​Type declaration

​LiveMediaLease

​Type declaration

​LiveMediaStatus

​Type declaration

​Interval

​Type declaration

​ModelSeriesOutcome

​ModelSeriesInput

​Type declaration

​ModelSeriesArguments

​Type declaration

​Stage

​Type declaration

​SourceRef

​Type declaration

​SeriesUploadOccurrence

​Type declaration

​SeriesUploadDestination

​SeriesEvent

​Type parameters

​Type declaration

​ResolvedValues

​Type parameters

​SeriesSample

​Type parameters

​Type declaration

​SeriesCoverage

​Type declaration

​SeriesPage

​Type parameters

​Type declaration

​SeriesInput

​Type parameters

​SeriesReceipt

​SeriesAppendReceipt

​Type parameters

​SeriesMeasureResult

​SeriesMeasureSummary

​Type declaration

​SeriesSummary

​Type declaration

​SeriesRange

​Type declaration

​SeriesWindowUnit

​SeriesWindows

​Type declaration

​SeriesChart

​Type declaration

​SeriesSignalSummary

​Type declaration

​SeriesSignalPolicy

​SeriesInterval

​Type declaration

​SeriesExecutionStats

​Type declaration

​SeriesPageOptions

​Type declaration

​SeriesAnalysisKind

​SeriesSettlementRequirement

Classes

Interfaces

References

resultRepresentationInput

ResultSpatialCell

ResultSpatialFeature

ResultSpatialPlan

ResultSpatialRepresentation

Type Aliases

ReadonlyAccessField

Type declaration

CheckedAccessBinding

Type parameters

Options

Type declaration

FieldsOfKind

Type parameters

LiveMediaOptions

Type declaration

LiveMediaTicket

Type declaration

LiveMediaLease

Type declaration

LiveMediaStatus

Type declaration

Interval

Type declaration

ModelSeriesOutcome

ModelSeriesInput

Type declaration

ModelSeriesArguments

Type declaration

Stage

Type declaration

SourceRef

Type declaration

SeriesUploadOccurrence

Type declaration

SeriesUploadDestination

SeriesEvent

Type parameters

Type declaration

ResolvedValues

Type parameters

SeriesSample

Type parameters

Type declaration

SeriesCoverage

Type declaration

SeriesPage

Type parameters

Type declaration

SeriesInput

Type parameters

SeriesReceipt

SeriesAppendReceipt

Type parameters

SeriesMeasureResult

SeriesMeasureSummary

Type declaration

SeriesSummary

Type declaration

SeriesRange

Type declaration

SeriesWindowUnit

SeriesWindows

Type declaration

SeriesChart

Type declaration

SeriesSignalSummary

Type declaration

SeriesSignalPolicy

SeriesInterval

Type declaration

SeriesExecutionStats

Type declaration

SeriesPageOptions

Type declaration

SeriesAnalysisKind

SeriesSettlementRequirement