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

package/dist/index-DbSxdR0f.d.ts

@@ -0,0 +1,824 @@
+import { A as AxisSensor, m as AxisPreSensor, l as AxisPostSensor, S as SensorInput, a as SensorDecision } from './axis-sensor-GBEI3Fab.js';
+import { x as CcePipelineConfig, s as CceHandler, b as CceRequestEnvelope, y as CcePipelineResult } from './cce-pipeline-DbGBSsCG.js';
+import { AxisFrame } from '@nextera.one/axis-protocol';
+import * as z from 'zod';
+
+type AxisExecutionMode = 'strict' | 'parallel' | 'best_effort' | 'atomic';
+type AxisObserverEvent = 'intent.received' | 'intent.completed' | 'intent.failed' | 'chain.received' | 'chain.admitted' | 'chain.completed' | 'chain.failed' | 'chain.partial' | 'step.started' | 'step.completed' | 'step.failed' | 'step.blocked' | 'step.skipped' | 'signature.verified' | 'decryption.succeeded' | 'sensor.passed' | 'sensor.failed' | 'handler.completed' | 'proof.recorded';
+interface AxisCapsuleRef {
+    capsuleId?: string;
+    scope?: string | string[];
+    scopeMode?: 'chain' | 'step' | 'chain+step';
+    proofRequired?: boolean;
+    metadata?: Record<string, unknown>;
+}
+interface AxisKeyExchangeRef {
+    profile?: string;
+    sessionId?: string;
+    clientKid?: string;
+    serverKid?: string;
+    algorithm?: string;
+    derivedKeyRef?: string;
+    required?: boolean;
+    metadata?: Record<string, unknown>;
+}
+interface AxisIntentEnvelope<TPayload = unknown> {
+    intent: string;
+    handler?: string;
+    payload: TPayload;
+    capsule?: AxisCapsuleRef;
+    keyExchange?: AxisKeyExchangeRef;
+    observerTags?: string[];
+    proofRequired?: boolean;
+    metadata?: Record<string, unknown>;
+}
+interface AxisChainStep<TInput = unknown> {
+    stepId: string;
+    intent: string;
+    handler?: string;
+    input?: TInput;
+    dependsOn?: string[];
+    onSuccess?: string[];
+    onFailure?: string[];
+    capsuleScope?: string | string[];
+    observerTags?: string[];
+    proofRequired?: boolean;
+    keyExchange?: AxisKeyExchangeRef;
+    metadata?: Record<string, unknown>;
+}
+interface AxisChainEncryption {
+    enabled?: boolean;
+    profile?: string;
+    keyExchange?: AxisKeyExchangeRef;
+}
+interface AxisChainEnvelope<TInput = unknown> {
+    chainId: string;
+    subject?: string;
+    issuer?: string;
+    issuedAtTps?: string | number;
+    expiresAtTps?: string | number;
+    mode: AxisExecutionMode;
+    signature?: string;
+    encryption?: AxisChainEncryption;
+    capsule?: AxisCapsuleRef;
+    keyExchange?: AxisKeyExchangeRef;
+    observerTags?: string[];
+    dynamic?: boolean;
+    metadata?: Record<string, unknown>;
+    steps: Array<AxisChainStep<TInput>>;
+}
+interface AxisChainRequest<TInput = unknown, TCapsule = Record<string, unknown>> {
+    envelope: AxisChainEnvelope<TInput>;
+    capsule?: TCapsule;
+    actorId?: string;
+}
+type AxisChainStepStatus = 'SUCCEEDED' | 'FAILED' | 'BLOCKED' | 'SKIPPED';
+interface AxisChainStepResult<TOutput = unknown> {
+    stepId: string;
+    intent: string;
+    status: AxisChainStepStatus;
+    effect?: string;
+    output?: TOutput;
+    error?: string;
+    dependsOn?: string[];
+    startedAt: number;
+    finishedAt: number;
+    proofHash?: string;
+    observerTags?: string[];
+    metadata?: Record<string, unknown>;
+}
+type AxisChainStatus = 'SUCCEEDED' | 'FAILED' | 'PARTIAL';
+interface AxisChainResult<TOutput = unknown> {
+    chainId: string;
+    mode: AxisExecutionMode;
+    status: AxisChainStatus;
+    completedSteps: number;
+    failedSteps: number;
+    blockedSteps: number;
+    skippedSteps: number;
+    startedAt: number;
+    finishedAt: number;
+    results: Array<AxisChainStepResult<TOutput>>;
+    rollback?: {
+        supported: boolean;
+        attempted: boolean;
+        reason?: string;
+    };
+    metadata?: Record<string, unknown>;
+}
+interface ChainOptions {
+    mode?: AxisExecutionMode;
+    allowPartial?: boolean;
+    dynamic?: boolean;
+    proofRequired?: boolean;
+    capsuleScope?: string | string[];
+    observerTags?: string[];
+    keyExchangeRequired?: boolean;
+}
+interface RegisteredChainConfig extends ChainOptions {
+    enabled: boolean;
+}
+
+declare const CAPSULE_POLICY_METADATA_KEY = "axis:capsule:policy";
+type CapsuleScopeMode = "all" | "any";
+interface CapsulePolicyOptions {
+    required?: boolean;
+    scopes?: string | string[];
+    scopeMode?: CapsuleScopeMode;
+    intentBound?: boolean;
+    allowCapsuleRef?: boolean;
+}
+declare function CapsulePolicy(options?: CapsulePolicyOptions): ClassDecorator & MethodDecorator;
+
+interface ExecutionContract {
+    maxDbWrites: number;
+    maxDbReads?: number;
+    maxExternalCalls: number;
+    maxTimeMs: number;
+    allowedEffects: string[];
+    maxMemoryMb?: number;
+}
+declare const DEFAULT_CONTRACTS: Record<string, ExecutionContract>;
+declare const FALLBACK_CONTRACT: ExecutionContract;
+
+declare const ProofKindZ: z.ZodEnum<{
+    NONE: "NONE";
+    CAPSULE: "CAPSULE";
+    PASSPORT: "PASSPORT";
+    MTLS: "MTLS";
+    JWT: "JWT";
+}>;
+type ProofKind = z.infer<typeof ProofKindZ>;
+declare const ProofPresenceInputZ: z.ZodObject<{
+    profile: z.ZodEnum<{
+        PUBLIC: "PUBLIC";
+        PARTNER: "PARTNER";
+        INTERNAL: "INTERNAL";
+        NODE: "NODE";
+    }>;
+    visibility: z.ZodEnum<{
+        PUBLIC: "PUBLIC";
+        GUARDED: "GUARDED";
+    }>;
+    requiredProof: z.ZodArray<z.ZodEnum<{
+        NONE: "NONE";
+        CAPSULE: "CAPSULE";
+        PASSPORT: "PASSPORT";
+        MTLS: "MTLS";
+        JWT: "JWT";
+    }>>;
+    hasCapsule: z.ZodBoolean;
+    hasPassportSignature: z.ZodBoolean;
+    intent: z.ZodString;
+}, z.z.core.$strip>;
+type ProofPresenceInput = z.infer<typeof ProofPresenceInputZ>;
+declare const SensitivityLevelZ: z.ZodEnum<{
+    LOW: "LOW";
+    MEDIUM: "MEDIUM";
+    HIGH: "HIGH";
+    CRITICAL: "CRITICAL";
+}>;
+type SensitivityLevel = z.infer<typeof SensitivityLevelZ>;
+declare enum ProofType {
+    CAPSULE = 1,
+    JWT = 2,
+    MTLS_ID = 3,
+    DEVICE_SE = 4,
+    WITNESS_SIG = 5
+}
+declare const AxisContextZ: z.ZodObject<{
+    pid: z.ZodCustom<Buffer<ArrayBufferLike>, Buffer<ArrayBufferLike>>;
+    ts: z.ZodBigInt;
+    intent: z.ZodString;
+    actorId: z.ZodCustom<Buffer<ArrayBufferLike>, Buffer<ArrayBufferLike>>;
+    proofType: z.ZodEnum<typeof ProofType>;
+    proofRef: z.ZodCustom<Buffer<ArrayBufferLike>, Buffer<ArrayBufferLike>>;
+    nonce: z.ZodCustom<Buffer<ArrayBufferLike>, Buffer<ArrayBufferLike>>;
+    ip: z.ZodString;
+    nodeCertHash: z.ZodOptional<z.ZodString>;
+    capsule: z.ZodOptional<z.ZodObject<{
+        id: z.ZodString;
+        claims: z.ZodObject<{
+            capsuleId: z.ZodString;
+            allowIntents: z.ZodArray<z.ZodString>;
+            limits: z.ZodOptional<z.ZodObject<{
+                maxBodyBytes: z.ZodOptional<z.ZodNumber>;
+            }, z.z.core.$strip>>;
+            scopes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+        }, z.z.core.$strip>;
+        issuedAt: z.ZodNumber;
+        expiresAt: z.ZodNumber;
+        tier: z.ZodEnum<{
+            FREE: "FREE";
+            STANDARD: "STANDARD";
+            PREMIUM: "PREMIUM";
+        }>;
+    }, z.z.core.$strip>>;
+    passport: z.ZodOptional<z.ZodObject<{
+        id: z.ZodString;
+        public_key: z.ZodCustom<Buffer<ArrayBufferLike>, Buffer<ArrayBufferLike>>;
+        status: z.ZodEnum<{
+            ACTIVE: "ACTIVE";
+            REVOKED: "REVOKED";
+            EXPIRED: "EXPIRED";
+            PENDING: "PENDING";
+        }>;
+        issuedAt: z.ZodNumber;
+        expiresAt: z.ZodOptional<z.ZodNumber>;
+    }, z.z.core.$strip>>;
+    meter: z.ZodOptional<z.ZodAny>;
+}, z.z.core.$strip>;
+type AxisContext = z.infer<typeof AxisContextZ>;
+
+declare const AXIS_META_KEY = "axis:axis";
+declare const SENSITIVITY_METADATA_KEY = "axis:sensitivity";
+declare const CONTRACT_METADATA_KEY = "axis:contract";
+declare const REQUIRED_PROOF_METADATA_KEY = "axis:required_proof";
+type RequiredProofKind = ProofKind | "WITNESS";
+declare function Sensitivity(level: SensitivityLevel): ClassDecorator & MethodDecorator;
+declare function Contract(options: Partial<ExecutionContract>): ClassDecorator & MethodDecorator;
+declare function RequiredProof(proofs: [RequiredProofKind, ...RequiredProofKind[]]): ClassDecorator & MethodDecorator;
+declare function Capsule(): ClassDecorator & MethodDecorator;
+declare function Witness(): ClassDecorator & MethodDecorator;
+declare function Axis(): ClassDecorator;
+declare const AXIS_PUBLIC_KEY = "axis:public";
+declare function AxisPublic(): ClassDecorator & MethodDecorator;
+declare const AXIS_ANONYMOUS_KEY = "axis:anonymous";
+declare function AxisAnonymous(): ClassDecorator & MethodDecorator;
+declare const AXIS_RATE_LIMIT_KEY = "axis:rateLimit";
+interface AxisRateLimitConfig {
+    max: number;
+    windowSec: number;
+    key?: string;
+}
+declare function AxisRateLimit(config: AxisRateLimitConfig): MethodDecorator;
+
+declare const INTENT_METADATA_KEY = "axis:intent";
+declare const INTENT_ROUTES_KEY = "axis:intent_routes";
+type IntentKind = "create" | "read" | "update" | "delete" | "action";
+type AxisIntentSensorRef = string | Function;
+interface AxisIntentSensorOptions {
+    is?: AxisIntentSensorRef[];
+}
+interface IntentTlvField {
+    name: string;
+    tag: number;
+    kind: "utf8" | "u64" | "bytes" | "bytes16" | "bool" | "obj" | "arr";
+    required?: boolean;
+    maxLen?: number;
+    max?: string;
+    scope?: "header" | "body";
+}
+interface IntentRoute extends AxisIntentSensorOptions {
+    action: string;
+    methodName: string | symbol;
+    absolute?: boolean;
+    frame?: boolean;
+    kind?: IntentKind;
+    sensitivity?: SensitivityLevel;
+    chain?: boolean | ChainOptions;
+    bodyProfile?: "TLV_MAP" | "RAW" | "TLV_OBJ" | "TLV_ARR";
+    tlv?: IntentTlvField[];
+    dto?: Function;
+}
+interface IntentOptions extends AxisIntentSensorOptions {
+    kind?: IntentKind;
+    sensitivity?: SensitivityLevel;
+    absolute?: boolean;
+    frame?: boolean;
+    chain?: boolean | ChainOptions;
+    bodyProfile?: "TLV_MAP" | "RAW" | "TLV_OBJ" | "TLV_ARR";
+    tlv?: IntentTlvField[];
+    dto?: Function;
+    decoder?: (buf: Buffer) => any;
+}
+declare function Intent(action: string, options?: IntentOptions): MethodDecorator;
+
+declare const OBSERVER_METADATA_KEY = "axis:observer";
+declare const OBSERVER_BINDINGS_KEY = "axis:observer:bindings";
+type AxisObserverRef = string | Function;
+interface AxisObserverDefinition {
+    name?: string;
+    tags?: string[];
+    events?: AxisObserverEvent[];
+    intents?: string[];
+    handlers?: string[];
+}
+interface AxisObserverBinding {
+    refs: AxisObserverRef[];
+    tags?: string[];
+    events?: AxisObserverEvent[];
+}
+interface AxisObserverBindingOptions {
+    use: AxisObserverRef | AxisObserverRef[];
+    tags?: string[];
+    events?: AxisObserverEvent[];
+}
+declare function Observer(input?: AxisObserverDefinition | AxisObserverBindingOptions | AxisObserverRef | AxisObserverRef[]): ClassDecorator & MethodDecorator;
+
+declare const TLV_FIELDS_KEY = "axis:tlv:fields";
+declare const TLV_VALIDATORS_KEY = "axis:tlv:validators";
+type TlvFieldKind = 'utf8' | 'u64' | 'bytes' | 'bytes16' | 'bool' | 'obj' | 'arr';
+interface TlvFieldOptions {
+    kind: TlvFieldKind;
+    required?: boolean;
+    maxLen?: number;
+    max?: string;
+    scope?: 'header' | 'body';
+}
+interface TlvFieldMeta {
+    property: string;
+    tag: number;
+    options: TlvFieldOptions;
+}
+type TlvValidatorFn = (value: Uint8Array, property: string) => string | null | undefined;
+interface TlvValidatorMeta {
+    property: string;
+    tag: number;
+    validators: TlvValidatorFn[];
+}
+declare function TlvField(tag: number, options: TlvFieldOptions): PropertyDecorator;
+declare function TlvValidate(validator: TlvValidatorFn): PropertyDecorator;
+declare function TlvUtf8Pattern(pattern: RegExp, message?: string): PropertyDecorator;
+declare function TlvMinLen(min: number, message?: string): PropertyDecorator;
+declare function TlvEnum(allowed: string[], message?: string): PropertyDecorator;
+declare function TlvRange(min: bigint, max: bigint, message?: string): PropertyDecorator;
+
+interface AxisDependencyResolver {
+    resolve<T = unknown>(token: string | Function): T | undefined;
+}
+
+interface AxisConfigReader {
+    get<T = string>(key: string): T | undefined;
+}
+declare class SensorRegistry {
+    private readonly configService?;
+    private sensors;
+    private sensorsByName;
+    private sensorsByType;
+    private readonly logger;
+    constructor(configService?: AxisConfigReader | undefined);
+    register(sensor: AxisSensor): void;
+    list(): AxisSensor[];
+    resolve(ref: AxisIntentSensorRef): AxisSensor | undefined;
+    getByName(name: string): AxisSensor | undefined;
+    getPreDecodeSensors(): AxisPreSensor[];
+    getPostDecodeSensors(): AxisPostSensor[];
+    getSensorCountByPhase(): {
+        preDecodeCount: number;
+        postDecodeCount: number;
+    };
+    clear(): void;
+    private isPreDecodeSensor;
+    private isPostDecodeSensor;
+    private indexSensor;
+}
+
+interface IntentSchema {
+    intent: string;
+    version: number;
+    bodyProfile: "TLV_MAP" | "RAW" | "TLV_OBJ" | "TLV_ARR";
+    fields: Array<{
+        name: string;
+        tlv: number;
+        kind: IntentTlvField["kind"];
+        required?: boolean;
+        maxLen?: number;
+        max?: string;
+        scope?: "header" | "body";
+    }>;
+}
+interface AxisEffect {
+    ok: boolean;
+    effect: string;
+    body?: Uint8Array;
+    headers?: Map<number, Uint8Array>;
+    metadata?: any;
+}
+declare class IntentRouter {
+    private readonly logger;
+    private readonly decoder;
+    private readonly encoder;
+    private readonly dependencyResolver?;
+    private readonly observerDispatcher?;
+    private readonly sensorRegistry?;
+    private static readonly BUILTIN_INTENTS;
+    private handlers;
+    private intentSensors;
+    private intentDecoders;
+    private intentSchemas;
+    private intentValidators;
+    private intentKinds;
+    private intentChains;
+    private intentObservers;
+    private intentCapsulePolicies;
+    private intentSensitivity;
+    private intentContracts;
+    private intentRequiredProof;
+    private publicIntents;
+    private anonymousIntents;
+    private intentRateLimits;
+    private cceHandlers;
+    private ccePipelineConfig;
+    constructor(dependencyResolver?: AxisDependencyResolver, observerDispatcher?: ObserverDispatcherService, sensorRegistry?: SensorRegistry);
+    getSchema(intent: string): IntentSchema | undefined;
+    getValidators(intent: string): Map<number, TlvValidatorFn[]> | undefined;
+    has(intent: string): boolean;
+    getRegisteredIntents(): string[];
+    getIntentEntry(intent: string): {
+        schema?: IntentSchema;
+        validators?: Map<number, TlvValidatorFn[]>;
+        hasSensors: boolean;
+        builtin: boolean;
+        kind?: IntentKind;
+        chain?: RegisteredChainConfig;
+        capsulePolicy?: CapsulePolicyOptions;
+        observerCount: number;
+    } | null;
+    getChainConfig(intent: string): RegisteredChainConfig | undefined;
+    getObservers(intent: string): AxisObserverBinding[];
+    register(intent: string, handler: any): void;
+    registerHandler(instance: any): void;
+    route(frame: AxisFrame): Promise<AxisEffect>;
+    private logIntent;
+    registerIntentMeta(intent: string, proto: object, methodName: string, handlerSensors?: AxisIntentSensorRef[], handlerObservers?: AxisObserverBinding[]): void;
+    getSensitivity(intent: string): SensitivityLevel | undefined;
+    getContract(intent: string): Record<string, any> | undefined;
+    getRequiredProof(intent: string): RequiredProofKind[] | undefined;
+    isPublic(intent: string): boolean;
+    isAnonymous(intent: string): boolean;
+    getRateLimit(intent: string): AxisRateLimitConfig | undefined;
+    private emitIntentObservers;
+    private runIntentSensors;
+    private resolveIntentSensor;
+    private getEffectiveCapsulePolicy;
+    private enforceCapsulePolicy;
+    private executeChainRequest;
+    private parseIntentExecBody;
+    private parseChainRequestBody;
+    private isChainRequestLike;
+    private isChainEnvelopeLike;
+    private encodeJson;
+    private getActorIdFromFrame;
+    private getProofRefFromFrame;
+    private hasCapsuleReference;
+    private getHeaderValue;
+    private identifiersMatch;
+    private extractInlineCapsuleId;
+    private toInlineCapsuleRecord;
+    private toScopeList;
+    configureCce(config: Omit<CcePipelineConfig, "handlers">): void;
+    registerCceHandler(intent: string, handler: CceHandler): void;
+    hasCceHandler(intent: string): boolean;
+    routeCce(envelope: CceRequestEnvelope): Promise<CcePipelineResult>;
+    private storeSchema;
+}
+
+interface AxisObserverContext {
+    event: AxisObserverEvent;
+    timestamp: number;
+    intent?: string;
+    chainId?: string;
+    stepId?: string;
+    handler?: string;
+    frame?: AxisFrame;
+    envelope?: AxisChainEnvelope;
+    step?: AxisChainStep;
+    effect?: AxisEffect;
+    result?: AxisChainStepResult | AxisChainResult;
+    error?: string;
+    observerTags?: string[];
+    capsule?: AxisCapsuleRef;
+    keyExchange?: AxisKeyExchangeRef;
+    metadata?: Record<string, unknown>;
+}
+interface AxisIntentObserver {
+    readonly name: string;
+    supports?(context: AxisObserverContext): boolean;
+    observe(context: AxisObserverContext): Promise<void> | void;
+}
+interface AxisObserverRegistration {
+    name: string;
+    instance: AxisIntentObserver;
+    tags: string[];
+    events?: AxisObserverEvent[];
+    intents?: string[];
+    handlers?: string[];
+}
+
+declare class ObserverRegistry {
+    private readonly logger;
+    private readonly byName;
+    private readonly byType;
+    register(instance: AxisIntentObserver, meta?: AxisObserverDefinition): void;
+    resolve(ref: AxisObserverRef): AxisObserverRegistration | undefined;
+    list(): AxisObserverRegistration[];
+    clear(): void;
+}
+
+declare class ObserverDispatcherService {
+    private readonly registry;
+    private readonly logger;
+    constructor(registry: ObserverRegistry);
+    dispatch(bindings: AxisObserverBinding[] | undefined, context: AxisObserverContext): Promise<void>;
+}
+
+type AxisLawDecision = "allow" | "deny" | "conditional";
+interface AxisLawArticleSummary {
+    article_id: string;
+    article_type?: string;
+    decision?: string;
+    reason?: string;
+}
+interface AxisLawEvaluationContext {
+    actorId?: string;
+    intent?: string;
+    audience?: string;
+    tps?: string | number;
+    country?: string;
+    ip?: string;
+    path?: string;
+    clientId?: string;
+    deviceId?: string;
+    sessionId?: string;
+    capsuleId?: string;
+    metadata: Record<string, unknown>;
+    packet?: Record<string, unknown>;
+    frameBody?: unknown;
+}
+interface AxisLawEvaluationResult {
+    decision: AxisLawDecision;
+    reason: string;
+    explanation?: string;
+    denied?: AxisLawArticleSummary[];
+    permitted?: AxisLawArticleSummary[];
+    required?: AxisLawArticleSummary[];
+    applicable?: AxisLawArticleSummary[];
+    metadata?: Record<string, unknown>;
+}
+type AxisLawEvaluator = ((context: AxisLawEvaluationContext) => AxisLawEvaluationResult | Promise<AxisLawEvaluationResult>);
+interface LawEvaluationSensorOptions {
+    evaluator?: AxisLawEvaluator;
+    conditionalDecision?: "deny" | "flag" | "allow";
+}
+declare function buildAxisLawEvaluationContext(input: SensorInput): AxisLawEvaluationContext;
+
+interface RiskSignal {
+    type: string;
+    severity: 'low' | 'medium' | 'high' | 'critical';
+    value: any;
+    message: string;
+}
+declare enum RiskDecision {
+    ALLOW = "ALLOW",
+    THROTTLE = "THROTTLE",
+    STEP_UP = "STEP_UP",
+    WITNESS = "WITNESS",
+    DENY = "DENY"
+}
+interface RiskEvaluation {
+    decision: RiskDecision;
+    reason?: string;
+    retryAfterMs?: number;
+    confidence: number;
+    signals: RiskSignal[];
+}
+
+declare class AccessProfileResolverSensor implements AxisSensor {
+    readonly name = "AccessProfileResolverSensor";
+    readonly order: number;
+    supports(): boolean;
+    run(input: SensorInput): Promise<SensorDecision>;
+}
+
+declare class BodyBudgetSensor implements AxisSensor {
+    readonly name = "BodyBudgetSensor";
+    readonly order: number;
+    supports(input: SensorInput): boolean;
+    run(input: SensorInput): Promise<SensorDecision>;
+}
+
+declare class CapabilityEnforcementSensor implements AxisSensor {
+    private readonly logger;
+    readonly name = "CapabilityEnforcementSensor";
+    readonly order: number;
+    supports(input: SensorInput): boolean;
+    run(input: SensorInput): Promise<SensorDecision>;
+    private getRequiredCapabilities;
+}
+
+declare class ChunkHashSensor implements AxisSensor {
+    readonly name = "ChunkHashSensor";
+    readonly order: number;
+    supports(input: SensorInput): boolean;
+    run(input: SensorInput): Promise<SensorDecision>;
+}
+
+declare class EntropySensor implements AxisSensor {
+    private readonly logger;
+    private readonly MIN_ENTROPY_THRESHOLD;
+    readonly name = "EntropySensor";
+    readonly order: number;
+    private calculateEntropy;
+    private hasSequentialPattern;
+    private hasRepeatedPattern;
+    run(input: SensorInput): Promise<SensorDecision>;
+    static generateSecureRandom(length: number): Uint8Array;
+}
+
+declare class ExecutionTimeoutSensor implements AxisSensor {
+    private readonly logger;
+    readonly name = "ExecutionTimeoutSensor";
+    readonly order: number;
+    supports(input: SensorInput): boolean;
+    run(input: SensorInput): Promise<SensorDecision>;
+    static isExpired(ctx: {
+        deadline?: number;
+    }): boolean;
+    static getRemainingMs(ctx: {
+        deadline?: number;
+    }): number;
+}
+
+declare class FrameBudgetSensor implements AxisSensor {
+    readonly name = "FrameBudgetSensor";
+    readonly order: number;
+    supports(input: SensorInput): boolean;
+    run(input: SensorInput): Promise<SensorDecision>;
+}
+
+declare class FrameHeaderSanitySensor implements AxisSensor {
+    readonly name = "FrameHeaderSanitySensor";
+    readonly order: number;
+    supports(input: SensorInput): boolean;
+    run(input: SensorInput): Promise<SensorDecision>;
+    private bufferEqual;
+}
+
+declare class HeaderTLVLimitSensor implements AxisSensor {
+    readonly name = "HeaderTLVLimitSensor";
+    readonly order: number;
+    private readonly MAX_TLVS;
+    supports(input: SensorInput): boolean;
+    run(input: SensorInput): Promise<SensorDecision>;
+}
+
+declare class IntentAllowlistSensor implements AxisSensor {
+    readonly name = "IntentAllowlistSensor";
+    readonly order: number;
+    supports(input: SensorInput): boolean;
+    run(input: SensorInput): Promise<SensorDecision>;
+}
+
+declare class IntentRegistrySensor implements AxisSensor {
+    private readonly router;
+    readonly name = "IntentRegistrySensor";
+    readonly order: number;
+    constructor(router: IntentRouter);
+    supports(input: SensorInput): boolean;
+    run(input: SensorInput): Promise<SensorDecision>;
+}
+
+declare class LawEvaluationSensor implements AxisSensor {
+    private readonly options;
+    private readonly logger;
+    readonly name = "LawEvaluationSensor";
+    readonly order: number;
+    constructor(options?: LawEvaluationSensorOptions);
+    supports(input: SensorInput): boolean;
+    run(input: SensorInput): Promise<SensorDecision>;
+}
+
+declare class ProofPresenceSensor implements AxisSensor {
+    readonly name = "ProofPresenceSensor";
+    readonly order: number;
+    supports(input: ProofPresenceInput): boolean;
+    run(input: ProofPresenceInput): Promise<SensorDecision>;
+}
+
+declare class ProtocolStrictSensor implements AxisSensor {
+    private readonly logger;
+    readonly name = "ProtocolStrictSensor";
+    readonly order: number;
+    private protocolMagic;
+    private protocolVersion;
+    static validateMagic(chunk: Uint8Array, expected: Uint8Array): {
+        valid: boolean;
+        actual?: string;
+    };
+    static validateVersion(version: number, expected: number): boolean;
+    onModuleInit(): void;
+    run(input: SensorInput): Promise<SensorDecision>;
+    private buffersEqual;
+    private isValidContentType;
+    private isValidFlags;
+    private checkVarintEncoding;
+    private checkTLVOrdering;
+    private checkForClientVersion;
+}
+
+declare class ReceiptPolicySensor implements AxisSensor {
+    readonly name = "ReceiptPolicySensor";
+    readonly order: number;
+    supports(): boolean;
+    run(): Promise<SensorDecision>;
+}
+
+type RiskSignalCollector = (input: SensorInput) => Promise<RiskSignal[]> | RiskSignal[];
+interface RiskGateSensorOptions {
+    collectors: RiskSignalCollector[];
+    denyThreshold?: number;
+    flagThreshold?: number;
+}
+declare class RiskGateSensor implements AxisSensor {
+    readonly name = "RiskGateSensor";
+    readonly order: number;
+    private readonly collectors;
+    private readonly denyThreshold;
+    private readonly flagThreshold;
+    constructor(options: RiskGateSensorOptions);
+    run(input: SensorInput): Promise<SensorDecision>;
+    private evaluate;
+}
+
+declare class SchemaValidationSensor implements AxisSensor {
+    readonly name = "SchemaValidationSensor";
+    readonly order: number;
+    supports(input: any): boolean;
+    run(input: any): Promise<{
+        action: 'ALLOW';
+    } | {
+        action: 'DENY';
+        code: string;
+        reason: string;
+    }>;
+}
+
+declare class StreamScopeSensor implements AxisSensor {
+    readonly name = "StreamScopeSensor";
+    readonly order: number;
+    supports(): boolean;
+    run(): Promise<SensorDecision>;
+}
+
+interface TickAuthCapsuleRef {
+    capsule_id: string;
+    capsule_type?: string;
+    intent?: string;
+    mode?: string;
+    verification?: {
+        status: 'approved' | 'denied' | 'expired' | 'replay_rejected' | 'consumed' | 'revoked';
+        reason?: string;
+    };
+    scope?: string[];
+    single_use?: boolean;
+    tick_index?: number;
+}
+type TickAuthVerifier = (capsule: TickAuthCapsuleRef, input: SensorInput) => Promise<string | null> | (string | null);
+interface TickAuthSensorOptions {
+    verifier?: TickAuthVerifier;
+    matchIntent?: boolean;
+    acceptTypes?: string[];
+}
+declare class TickAuthSensor implements AxisSensor {
+    readonly name = "TickAuthSensor";
+    readonly order: number;
+    private readonly verifier?;
+    private readonly matchIntent;
+    private readonly acceptTypes;
+    constructor(options?: TickAuthSensorOptions);
+    supports(input: SensorInput): boolean;
+    run(input: SensorInput): Promise<SensorDecision>;
+}
+
+declare class TLVParseSensor implements AxisSensor {
+    readonly name = "TLVParseSensor";
+    readonly order: number;
+    supports(input: SensorInput): boolean;
+    run(input: SensorInput): Promise<SensorDecision>;
+    private validateCanonicalTLV;
+}
+
+interface TpsSensorOptions {
+    maxDriftMs?: number;
+    resolver?: (tps: string) => number | null;
+}
+declare class TpsSensor implements AxisSensor {
+    readonly name = "TpsSensor";
+    readonly order: number;
+    private readonly maxDriftMs;
+    private readonly resolver;
+    constructor(options?: TpsSensorOptions);
+    supports(input: SensorInput): boolean;
+    run(input: SensorInput): Promise<SensorDecision>;
+}
+
+declare class VarintHardeningSensor implements AxisSensor {
+    readonly name = "VarintHardeningSensor";
+    readonly order: number;
+    private readonly MAX_VARINT_BYTES;
+    supports(input: SensorInput): boolean;
+    run(input: SensorInput): Promise<SensorDecision>;
+}
+
+export { ChunkHashSensor as $, type AxisIntentSensorRef as A, type AxisLawEvaluationContext as B, type ChainOptions as C, type AxisLawEvaluationResult as D, type AxisLawEvaluator as E, type AxisObserverBinding as F, type AxisObserverBindingOptions as G, type AxisObserverContext as H, type IntentTlvField as I, type AxisObserverDefinition as J, type AxisObserverEvent as K, type AxisObserverRef as L, type AxisObserverRegistration as M, AxisPublic as N, ObserverDispatcherService as O, AxisRateLimit as P, type AxisRateLimitConfig as Q, BodyBudgetSensor as R, SensorRegistry as S, type TlvValidatorFn as T, CAPSULE_POLICY_METADATA_KEY as U, CONTRACT_METADATA_KEY as V, CapabilityEnforcementSensor as W, Capsule as X, CapsulePolicy as Y, type CapsulePolicyOptions as Z, type CapsuleScopeMode as _, IntentRouter as a, Contract as a0, DEFAULT_CONTRACTS as a1, EntropySensor as a2, type ExecutionContract as a3, ExecutionTimeoutSensor as a4, FALLBACK_CONTRACT as a5, FrameBudgetSensor as a6, FrameHeaderSanitySensor as a7, HeaderTLVLimitSensor as a8, INTENT_METADATA_KEY as a9, SENSITIVITY_METADATA_KEY as aA, SchemaValidationSensor as aB, Sensitivity as aC, StreamScopeSensor as aD, TLVParseSensor as aE, TLV_FIELDS_KEY as aF, TLV_VALIDATORS_KEY as aG, type TickAuthCapsuleRef as aH, TickAuthSensor as aI, type TickAuthSensorOptions as aJ, type TickAuthVerifier as aK, TlvEnum as aL, TlvField as aM, type TlvFieldKind as aN, type TlvFieldMeta as aO, type TlvFieldOptions as aP, TlvMinLen as aQ, TlvRange as aR, TlvUtf8Pattern as aS, TlvValidate as aT, type TlvValidatorMeta as aU, TpsSensor as aV, type TpsSensorOptions as aW, VarintHardeningSensor as aX, Witness as aY, buildAxisLawEvaluationContext as aZ, INTENT_ROUTES_KEY as aa, Intent as ab, IntentAllowlistSensor as ac, type IntentKind as ad, type IntentOptions as ae, IntentRegistrySensor as af, type IntentRoute as ag, LawEvaluationSensor as ah, type LawEvaluationSensorOptions as ai, OBSERVER_BINDINGS_KEY as aj, OBSERVER_METADATA_KEY as ak, Observer as al, ObserverRegistry as am, ProofPresenceSensor as an, ProtocolStrictSensor as ao, REQUIRED_PROOF_METADATA_KEY as ap, ReceiptPolicySensor as aq, type RegisteredChainConfig as ar, RequiredProof as as, type RequiredProofKind as at, RiskDecision as au, type RiskEvaluation as av, RiskGateSensor as aw, type RiskGateSensorOptions as ax, type RiskSignal as ay, type RiskSignalCollector as az, type AxisChainEnvelope as b, type AxisChainResult as c, type AxisCapsuleRef as d, type AxisChainStep as e, type AxisContext as f, AXIS_ANONYMOUS_KEY as g, AXIS_META_KEY as h, AXIS_PUBLIC_KEY as i, AXIS_RATE_LIMIT_KEY as j, AccessProfileResolverSensor as k, Axis as l, AxisAnonymous as m, type AxisChainEncryption as n, type AxisChainRequest as o, type AxisChainStatus as p, type AxisChainStepResult as q, type AxisChainStepStatus as r, type AxisEffect as s, type AxisExecutionMode as t, type AxisIntentEnvelope as u, type AxisIntentObserver as v, type AxisIntentSensorOptions as w, type AxisKeyExchangeRef as x, type AxisLawArticleSummary as y, type AxisLawDecision as z };