@nextera.one/axis-server-sdk 2.2.1 → 2.2.2

package/dist/index-l3Hhirqb.d.ts

@@ -0,0 +1,501 @@
+import { c as CompiledIntent } from './idel.types-DuUAcOnQ.js';
+import { i as TimelineEvent } from './timeline.types-Cn0aqbUj.js';
+import { A as AxisSensor } from './axis-sensor-GBEI3Fab.js';
+
+interface ObservationStage {
+    name: string;
+    status: 'ok' | 'fail' | 'skip';
+    startMs: number;
+    endMs?: number;
+    durationMs?: number;
+    reason?: string;
+    code?: string;
+}
+interface ObservationSensor {
+    name: string;
+    allowed: boolean;
+    riskScore: number;
+    durationMs: number;
+    reasons: string[];
+    code?: string;
+}
+interface AxisObservation {
+    id: string;
+    startMs: number;
+    transport: 'http' | 'ws';
+    ip?: string;
+    intent?: string;
+    actorId?: string;
+    capsuleId?: string;
+    stages: ObservationStage[];
+    sensors: ObservationSensor[];
+    decision?: 'ALLOW' | 'DENY';
+    resultCode?: string;
+    statusCode?: number;
+    endMs?: number;
+    durationMs?: number;
+    facts: Record<string, unknown>;
+}
+declare function createObservation(transport: 'http' | 'ws', ip?: string): AxisObservation;
+declare function startStage(obs: AxisObservation, name: string): ObservationStage;
+declare function endStage(stage: ObservationStage, status?: 'ok' | 'fail' | 'skip', reason?: string, code?: string): void;
+declare function recordSensor(obs: AxisObservation, name: string, allowed: boolean, riskScore: number, durationMs: number, reasons: string[], code?: string): void;
+declare function finalizeObservation(obs: AxisObservation, decision: 'ALLOW' | 'DENY', statusCode: number, resultCode?: string): void;
+
+type TruthStatus = 'confirmed' | 'partial' | 'uncertain' | 'failed' | 'disputed';
+interface ExpectedOutcome {
+    decision?: 'ALLOW' | 'DENY';
+    effect?: string;
+    statusCode?: number;
+    ok?: boolean;
+    stateChanges?: Record<string, unknown>;
+    maxDurationMs?: number;
+    minSensorsPassed?: number;
+    assertions?: Record<string, unknown>;
+}
+type AnomalyLevel = 'info' | 'warning' | 'critical';
+interface Anomaly {
+    code: string;
+    level: AnomalyLevel;
+    message: string;
+    field?: string;
+    expected?: unknown;
+    actual?: unknown;
+}
+interface TruthVerdict {
+    status: TruthStatus;
+    confidence: number;
+    anomalies: Anomaly[];
+    passedChecks: number;
+    totalChecks: number;
+    verifiedAt: number;
+    isDeed: boolean;
+}
+declare function scoreTruth(obs: AxisObservation, expected?: ExpectedOutcome): TruthVerdict;
+interface ObservedDeed {
+    observation: AxisObservation;
+    verdict: TruthVerdict;
+}
+declare function verifyObservation(obs: AxisObservation, expected?: ExpectedOutcome): ObservedDeed;
+
+interface PresenceDeclaration {
+    softid: string;
+    device_meta?: {
+        fingerprint?: string;
+        platform?: string;
+        user_agent?: string;
+    };
+}
+interface PresenceChallenge {
+    challenge_id: string;
+    nonce: string;
+    temporal_anchor: number;
+    ttl_ms: number;
+    expires_at: number;
+}
+interface PresenceProof {
+    challenge_id: string;
+    signature: string;
+    public_key: string;
+    kid?: string;
+}
+interface PresenceReceipt {
+    presence_id: string;
+    softid: string;
+    anchor_reflection: string;
+    scope: {
+        ip?: string;
+        device_fingerprint?: string;
+    };
+    issued_at: number;
+    expires_at: number;
+    renewed_at?: number;
+}
+type PresenceStatus = 'active' | 'expired' | 'revoked';
+interface WritHead {
+    tid: string;
+    seq: number;
+}
+interface WritBody {
+    who: string;
+    act: string;
+    res: string;
+    law: string;
+}
+interface WritMeta {
+    iat: number;
+    exp: number;
+    prev: string;
+}
+interface WritSignature {
+    alg: 'ed25519';
+    value: string;
+    kid?: string;
+}
+interface Writ {
+    head: WritHead;
+    body: WritBody;
+    meta: WritMeta;
+    sig: WritSignature;
+}
+type GrantType = 'sovereign' | 'delegated' | 'system';
+interface GrantCapability {
+    oec: string;
+    scope: string;
+    limit?: {
+        rate?: string;
+        amount?: number;
+        depth?: string;
+    };
+}
+interface GrantMeta {
+    iat: number;
+    exp: number;
+    revocable: boolean;
+    version: number;
+    contract_ref?: string;
+}
+interface Grant {
+    grant_id: string;
+    issuer: string;
+    subject: string;
+    grant_type: GrantType;
+    caps: GrantCapability[];
+    meta: GrantMeta;
+    sig: WritSignature;
+}
+type GrantStatus = 'active' | 'revoked' | 'expired';
+interface LoomReceipt {
+    receipt_id: string;
+    writ_hash: string;
+    thread_id: string;
+    sequence: number;
+    effect: string;
+    hash: string;
+    prev_hash: string | null;
+    executed_at: number;
+    metadata?: Record<string, unknown>;
+}
+interface ThreadState {
+    thread_id: string;
+    softid: string;
+    last_receipt_hash: string;
+    sequence: number;
+    updated_at: number;
+}
+type RevocationTargetType = 'grant' | 'presence' | 'softid';
+interface Revocation {
+    revocation_id: string;
+    target_type: RevocationTargetType;
+    target_id: string;
+    issuer_softid: string;
+    reason?: string;
+    effective_at: number;
+    sig_value: string;
+}
+interface LoomValidationResult {
+    valid: boolean;
+    error?: string;
+    code?: string;
+}
+interface PresenceVerifyResult extends LoomValidationResult {
+    presence?: PresenceReceipt;
+}
+interface WritValidationResult extends LoomValidationResult {
+    writ?: Writ;
+    gate_failed?: 'temporal' | 'causal' | 'legal' | 'authentic';
+}
+interface GrantValidationResult extends LoomValidationResult {
+    grant?: Grant;
+}
+
+declare function deriveAnchorReflection(softid: string, context?: string, scope?: string): string;
+declare function canonicalizeWrit(writ: Omit<Writ, 'sig'>): string;
+declare function canonicalizeGrant(grant: Omit<Grant, 'sig'>): string;
+
+type NeedlePhase = 'created' | 'validated' | 'executing' | 'observed' | 'stitched' | 'failed';
+interface Needle {
+    needle_id: string;
+    phase: NeedlePhase;
+    tps_coordinate?: string;
+    intent: CompiledIntent;
+    presence: PresenceReceipt;
+    writ: Writ;
+    grants: Grant[];
+    observation?: AxisObservation;
+    receipt?: LoomReceipt;
+    verdict?: TruthVerdict;
+    created_at: number;
+    completed_at?: number;
+    error?: NeedleError;
+}
+interface NeedleError {
+    phase: NeedlePhase;
+    code: string;
+    message: string;
+}
+type StitchKind = 'deed' | 'silent' | 'torn';
+interface Stitch {
+    stitch_id: string;
+    kind: StitchKind;
+    intent: string;
+    actor_id: string;
+    tps_coordinate?: string;
+    observation: AxisObservation;
+    verdict: TruthVerdict;
+    receipt: LoomReceipt;
+    thread_id: string;
+    sequence: number;
+    timeline_event_id?: string;
+    stitched_at: number;
+}
+interface Thread {
+    state: ThreadState;
+    length: number;
+    started_at_tps?: string;
+    last_stitch_tps?: string;
+    has_branches: boolean;
+    branch_ids: string[];
+}
+
+type NeedleHandler = (intent: CompiledIntent, context: NeedleHandlerContext) => Promise<NeedleHandlerResult>;
+interface NeedleHandlerContext {
+    needle_id: string;
+    actor_id: string;
+    presence_id: string;
+    writ: Writ;
+    grants: Grant[];
+    tps_coordinate?: string;
+}
+interface NeedleHandlerResult {
+    ok: boolean;
+    effect: string;
+    data?: Record<string, unknown>;
+    status_code?: number;
+}
+interface NeedlePipelineConfig {
+    handlers: Map<string, NeedleHandler>;
+    private_key: string;
+    public_key: string;
+    sensors?: AxisSensor[];
+    record_timeline?: boolean;
+    tps_provider?: () => string;
+}
+interface NeedlePipelineResult {
+    ok: boolean;
+    needle: Needle;
+    stitch?: Stitch;
+    thread_state?: ThreadState;
+    timeline_event?: TimelineEvent;
+}
+
+declare function assembleNeedle(params: {
+    intent: CompiledIntent;
+    presence: PresenceReceipt;
+    writ: Writ;
+    grants: Grant[];
+    tps_coordinate?: string;
+}): Needle;
+declare function formStitch(needle: Needle, observation: AxisObservation, verdict: TruthVerdict, receipt: LoomReceipt): Stitch;
+declare function runNeedlePipeline(needle: Needle, config: NeedlePipelineConfig, threadState: ThreadState | null, prevReceipt: LoomReceipt | null, expectedOutcome?: ExpectedOutcome): Promise<NeedlePipelineResult>;
+
+type KnotType = 'authority' | 'law' | 'causal' | 'decision' | 'irreversible';
+type KnotStatus = 'open' | 'tied' | 'broken' | 'forked';
+interface Knot {
+    knot_id: string;
+    type: KnotType;
+    status: KnotStatus;
+    stitch_ids: string[];
+    thread_id: string;
+    tps_anchor?: string;
+    irreversible: boolean;
+    capsule_id?: string;
+    law_ref?: string;
+    decision_stitch_id?: string;
+    branch_ids: string[];
+    required_count?: number;
+    all_or_nothing: boolean;
+    actor_id: string;
+    created_at: number;
+    tied_at?: number;
+    broken_at?: number;
+    break_reason?: string;
+    witness_hash?: string;
+}
+interface KnotValidationResult {
+    valid: boolean;
+    passed_stitch_ids: string[];
+    failed_stitch_ids: string[];
+    can_tie: boolean;
+    errors: KnotError[];
+}
+interface KnotError {
+    code: string;
+    message: string;
+    stitch_id?: string;
+}
+interface KnotBreakRequest {
+    knot_id: string;
+    actor_id: string;
+    reason: string;
+    override_grant_id?: string;
+    signature?: string;
+}
+
+interface OpenKnotParams {
+    type: KnotType;
+    thread_id: string;
+    actor_id: string;
+    tps_anchor?: string;
+    capsule_id?: string;
+    law_ref?: string;
+    required_count?: number;
+    all_or_nothing?: boolean;
+}
+declare function openKnot(params: OpenKnotParams): Knot;
+declare function addStitchToKnot(knot: Knot, stitch: Stitch): string | null;
+declare function validateKnot(knot: Knot, stitches: Stitch[]): KnotValidationResult;
+declare function tieKnot(knot: Knot, stitches: Stitch[]): KnotValidationResult & {
+    knot: Knot;
+};
+declare function breakKnot(knot: Knot, request: KnotBreakRequest): {
+    ok: boolean;
+    error?: string;
+};
+declare function forkFromKnot(knot: Knot, branchId: string, decisionStitchId?: string): {
+    ok: boolean;
+    error?: string;
+};
+declare function isKnotOpen(knot: Knot): boolean;
+declare function isPointOfNoReturn(knot: Knot): boolean;
+declare function findKnotsForStitch(stitchId: string, knots: Knot[]): Knot[];
+declare function getIrreversibleKnots(knots: Knot[]): Knot[];
+declare function getDecisionPoints(knots: Knot[]): Knot[];
+
+interface FabricCell {
+    key: string;
+    value: unknown;
+    last_stitch_id: string;
+    last_tps?: string;
+    write_count: number;
+    locked: boolean;
+    locked_by_knot?: string;
+}
+interface Fabric {
+    fabric_id: string;
+    state_hash: string;
+    cells: Map<string, FabricCell>;
+    thread_ids: string[];
+    stitch_count: number;
+    knot_count: number;
+    projected_at_tps?: string;
+    computed_at: number;
+    version: number;
+}
+interface FabricEffect {
+    mutations: Record<string, unknown | null>;
+    reads?: string[];
+}
+type FabricEffectResolver = (stitch: Stitch) => FabricEffect;
+type FabricDiffKind = 'added' | 'modified' | 'deleted';
+interface FabricDiffEntry {
+    key: string;
+    kind: FabricDiffKind;
+    before?: unknown;
+    after?: unknown;
+    caused_by_stitch?: string;
+}
+interface FabricDiff {
+    from_fabric_id: string;
+    to_fabric_id: string;
+    entries: FabricDiffEntry[];
+    added_count: number;
+    modified_count: number;
+    deleted_count: number;
+}
+interface FabricQuery {
+    prefix?: string;
+    keys?: string[];
+    actor_id?: string;
+    thread_id?: string;
+    locked_only?: boolean;
+}
+
+declare function createFabric(): Fabric;
+declare function applyStitch(fabric: Fabric, stitch: Stitch, effect: FabricEffect): void;
+declare function weave(stitches: Stitch[], resolver: FabricEffectResolver, knots?: Knot[]): Fabric;
+declare function projectAt(stitches: Stitch[], resolver: FabricEffectResolver, tpsFilter: (tps: string | undefined) => boolean, knots?: Knot[]): Fabric;
+declare function lockCells(fabric: Fabric, keys: string[], knotId: string): void;
+declare function queryFabric(fabric: Fabric, query: FabricQuery): FabricCell[];
+declare function getFabricValue(fabric: Fabric, key: string): unknown | undefined;
+declare function diffFabrics(a: Fabric, b: Fabric): FabricDiff;
+
+type PatternKind = 'sequence' | 'knot' | 'state' | 'decision' | 'anomaly';
+type PatternConfidence = number;
+interface Pattern {
+    pattern_id: string;
+    kind: PatternKind;
+    name: string;
+    description?: string;
+    signature: PatternSignature;
+    confidence: PatternConfidence;
+    occurrence_count: number;
+    first_seen_at: number;
+    last_seen_at: number;
+    seen_in_threads: string[];
+    classification: 'normal' | 'anomalous' | 'unclassified';
+    predicted_next?: PatternPrediction;
+}
+interface PatternSignature {
+    intent_sequence?: string[];
+    stitch_kinds?: StitchKind[];
+    knot_type?: KnotType;
+    knot_size?: number;
+    state_keys?: string[];
+    state_mutations?: Record<string, 'created' | 'updated' | 'deleted'>;
+    decision_outcome?: string;
+    actor?: string;
+    min_length?: number;
+    max_length?: number;
+}
+interface PatternMatch {
+    pattern_id: string;
+    matched_stitch_ids: string[];
+    matched_knot_ids?: string[];
+    match_score: number;
+    thread_id: string;
+    detected_at: number;
+}
+interface PatternPrediction {
+    next_intent: string;
+    confidence: PatternConfidence;
+    alternatives: Array<{
+        intent: string;
+        confidence: PatternConfidence;
+    }>;
+    predicted_outcome?: string;
+    risk_note?: string;
+}
+interface PatternStore {
+    save(pattern: Pattern): void;
+    get(patternId: string): Pattern | undefined;
+    findByKind(kind: PatternKind): Pattern[];
+    findByIntent(intent: string): Pattern[];
+    all(): Pattern[];
+}
+
+declare class InMemoryPatternStore implements PatternStore {
+    private patterns;
+    save(pattern: Pattern): void;
+    get(patternId: string): Pattern | undefined;
+    findByKind(kind: PatternKind): Pattern[];
+    findByIntent(intent: string): Pattern[];
+    all(): Pattern[];
+}
+declare function detectSequencePatterns(stitches: Stitch[], windowSize: number, minOccurrences: number): Pattern[];
+declare function detectKnotPatterns(knots: Knot[], minOccurrences: number): Pattern[];
+declare function matchPatterns(stitches: Stitch[], patterns: Pattern[]): PatternMatch[];
+declare function recordOccurrence(pattern: Pattern, threadId: string): void;
+declare function detectAnomalies(recentStitches: Stitch[], knownPatterns: Pattern[], threshold?: number): Pattern[];
+
+export { type PatternMatch as $, type AxisObservation as A, type KnotValidationResult as B, type LoomValidationResult as C, type NeedleError as D, type ExpectedOutcome as E, type Fabric as F, type Grant as G, type NeedleHandler as H, InMemoryPatternStore as I, type NeedleHandlerContext as J, type Knot as K, type LoomReceipt as L, type NeedleHandlerResult as M, type Needle as N, type NeedlePhase as O, type PresenceDeclaration as P, type NeedlePipelineConfig as Q, type Revocation as R, type NeedlePipelineResult as S, type ThreadState as T, type ObservationSensor as U, type ObservationStage as V, type WritValidationResult as W, type ObservedDeed as X, type Pattern as Y, type PatternConfidence as Z, type PatternKind as _, type GrantCapability as a, type PatternPrediction as a0, type PatternSignature as a1, type PatternStore as a2, type RevocationTargetType as a3, type Stitch as a4, type StitchKind as a5, type Thread as a6, type TruthStatus as a7, type TruthVerdict as a8, type WritHead as a9, openKnot as aA, projectAt as aB, queryFabric as aC, recordOccurrence as aD, recordSensor as aE, runNeedlePipeline as aF, scoreTruth as aG, startStage as aH, tieKnot as aI, validateKnot as aJ, verifyObservation as aK, weave as aL, type OpenKnotParams as aM, type WritSignature as aa, addStitchToKnot as ab, applyStitch as ac, assembleNeedle as ad, breakKnot as ae, canonicalizeGrant as af, canonicalizeWrit as ag, createFabric as ah, createObservation as ai, deriveAnchorReflection as aj, detectAnomalies as ak, detectKnotPatterns as al, detectSequencePatterns as am, diffFabrics as an, endStage as ao, finalizeObservation as ap, findKnotsForStitch as aq, forkFromKnot as ar, formStitch as as, getDecisionPoints as at, getFabricValue as au, getIrreversibleKnots as av, isKnotOpen as aw, isPointOfNoReturn as ax, lockCells as ay, matchPatterns as az, type PresenceChallenge as b, type Writ as c, type WritBody as d, type WritMeta as e, type PresenceReceipt as f, type GrantStatus as g, type PresenceStatus as h, type PresenceProof as i, type GrantValidationResult as j, type PresenceVerifyResult as k, type Anomaly as l, type AnomalyLevel as m, type FabricCell as n, type FabricDiff as o, type FabricDiffEntry as p, type FabricDiffKind as q, type FabricEffect as r, type FabricEffectResolver as s, type FabricQuery as t, type GrantMeta as u, type GrantType as v, type KnotBreakRequest as w, type KnotError as x, type KnotStatus as y, type KnotType as z };