@nextera.one/axis-server-sdk 1.2.0 → 1.3.0

package/dist/index.d.ts

@@ -1,7 +1,11 @@
-import { AxisFrame as AxisFrame$1 } from './core/index.js';
-export { AxisBinaryFrame, AxisFrameZ, computeReceiptHash, computeSignaturePayload, decodeFrame, encodeFrame, generateEd25519KeyPair, getSignTarget, sha256, signFrame, verifyFrameSignature } from './core/index.js';
+import { ModuleRef, DiscoveryService, MetadataScanner, Reflector } from '@nestjs/core';
+import { A as AxisFrame$2 } from './index-B5xzROld.js';
+export { a as AxisBinaryFrame, b as AxisFrameZ, c as computeReceiptHash, d as computeSignaturePayload, i as core, e as decodeFrame, f as encodeFrame, g as generateEd25519KeyPair, h as getSignTarget, s as sha256, j as signFrame, v as verifyFrameSignature } from './index-B5xzROld.js';
+import { PROOF_LOOM, TLV_LOOM_PRESENCE_ID, TLV_LOOM_THREAD_HASH, TLV_LOOM_WRIT } from '@nextera.one/axis-protocol';
 export { AXIS_MAGIC, AXIS_VERSION, TLV as AxisTlvType, BodyProfile, ERR_BAD_SIGNATURE, ERR_CONTRACT_VIOLATION, ERR_INVALID_PACKET, ERR_REPLAY_DETECTED, FLAG_BODY_TLV, FLAG_CHAIN_REQ, FLAG_HAS_WITNESS, MAX_BODY_LEN, MAX_FRAME_LEN, MAX_HDR_LEN, MAX_SIG_LEN, NCERT_ALG, NCERT_EXP, NCERT_ISSUER_KID, NCERT_KID, NCERT_NBF, NCERT_NODE_ID, NCERT_PAYLOAD, NCERT_PUB, NCERT_SCOPE, NCERT_SIG, PROOF_CAPSULE, PROOF_JWT, PROOF_LOOM, PROOF_MTLS, PROOF_NONE, PROOF_WITNESS, ProofType, TLV, TLV_ACTOR_ID, TLV_AUD, TLV_BODY_ARR, TLV_BODY_OBJ, TLV_CAPSULE, TLV_EFFECT, TLV_ERROR_CODE, TLV_ERROR_MSG, TLV_INDEX, TLV_INTENT, TLV_KID, TLV_LOOM_PRESENCE_ID, TLV_LOOM_THREAD_HASH, TLV_LOOM_WRIT, TLV_NODE, TLV_NODE_CERT_HASH, TLV_NODE_KID, TLV_NONCE, TLV_OFFSET, TLV_OK, TLV_PID, TLV_PREV_HASH, TLV_PROOF_REF, TLV_PROOF_TYPE, TLV_REALM, TLV_RECEIPT_HASH, TLV_RID, TLV_SHA256_CHUNK, TLV_TRACE_ID, TLV_TS, TLV_UPLOAD_ID, decodeArray, decodeObject, decodeTLVs, decodeTLVsList, decodeVarint, encodeTLVs, encodeVarint, varintLength } from '@nextera.one/axis-protocol';
-import 'zod';
+import * as z from 'zod';
+import { OnModuleInit, OnApplicationBootstrap } from '@nestjs/common';
+import { ConfigService } from '@nestjs/config';
 
 declare const HANDLER_METADATA_KEY = "axis:handler";
 declare function Handler(intent?: string): ClassDecorator;
@@ -38,6 +42,12 @@ interface IntentOptions {
 }
 declare function Intent(action: string, options?: IntentOptions): MethodDecorator;
 
+declare const INTENT_BODY_KEY = "axis:intent:body";
+declare function IntentBody(decoder: (buf: Buffer) => any): MethodDecorator;
+
+declare const INTENT_SENSORS_KEY = "axis:intent:sensors";
+declare function IntentSensors(sensors: Function[]): 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';
@@ -95,6 +105,20 @@ declare abstract class AxisResponseDto extends AxisTlvDto {
     updated_by?: string;
 }
 
+interface IntentSchema$1 {
+    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;
@@ -103,11 +127,34 @@ interface AxisEffect {
     metadata?: any;
 }
 declare class IntentRouter {
+    private readonly moduleRef?;
+    private readonly logger;
+    private static readonly BUILTIN_INTENTS;
     private handlers;
+    private intentSensors;
+    private intentDecoders;
+    private intentSchemas;
+    private intentValidators;
+    private intentKinds;
+    constructor(moduleRef?: ModuleRef | undefined);
+    getSchema(intent: string): IntentSchema$1 | undefined;
+    getValidators(intent: string): Map<number, TlvValidatorFn[]> | undefined;
+    has(intent: string): boolean;
+    getRegisteredIntents(): string[];
+    getIntentEntry(intent: string): {
+        schema?: IntentSchema$1;
+        validators?: Map<number, TlvValidatorFn[]>;
+        hasSensors: boolean;
+        builtin: boolean;
+        kind?: IntentKind;
+    } | null;
     register(intent: string, handler: any): void;
     registerHandler(instance: any): void;
-    route(frame: AxisFrame$1): Promise<AxisEffect>;
-    private recordLatency;
+    route(frame: AxisFrame$2): Promise<AxisEffect>;
+    private logIntent;
+    registerIntentMeta(intent: string, proto: object, methodName: string): void;
+    private runIntentSensors;
+    private storeSchema;
 }
 
 declare const ATS1_HDR: {
@@ -385,6 +432,7 @@ declare function canonicalJson(value: any): string;
 declare function canonicalJsonExcluding(obj: Record<string, any>, exclude: string[]): string;
 
 type AxisAlg$1 = 'EdDSA' | 'ES256' | 'RS256';
+type CapsuleStatus = 'ACTIVE' | 'CONSUMED' | 'REVOKED' | 'EXPIRED';
 type CapsuleMode = 'SINGLE_USE' | 'MULTI_USE';
 type KeyStatus = 'ACTIVE' | 'GRACE' | 'REVOKED' | 'RETIRED';
 interface AxisSig$1 {
@@ -438,6 +486,40 @@ interface AxisCapsulePayload {
     constraints?: AxisCapsuleConstraints;
     meta?: Record<string, unknown>;
 }
+interface AxisCapsule {
+    payload: AxisCapsulePayload;
+    sig: AxisSig$1;
+}
+interface CapsuleIssueBody {
+    intent: string;
+    audience: string;
+    scopes: string[];
+    subject?: string;
+    mode: CapsuleMode;
+    maxUses?: number;
+    expSeconds?: number;
+    constraints?: AxisCapsuleConstraints;
+    hints?: {
+        ip?: string;
+        ua?: string;
+        deviceId?: string;
+        geo?: string;
+    };
+}
+interface CapsuleBatchBody extends Omit<CapsuleIssueBody, 'mode' | 'maxUses'> {
+    count: number;
+    mode: 'SINGLE_USE';
+}
+interface IntentExecBody {
+    intent: string;
+    capsule: AxisCapsule;
+    execNonce?: string;
+    args: Record<string, any>;
+}
+interface CapsuleRevokeBody {
+    capsuleId: string;
+    reason: string;
+}
 interface AxisResponse$1<T = any> {
     ok: boolean;
     pid: string;
@@ -447,6 +529,71 @@ interface AxisResponse$1<T = any> {
     data?: T;
     meta?: Record<string, unknown>;
 }
+interface CapsuleIssueResult {
+    capsule: AxisCapsule;
+}
+interface CapsuleBatchResult {
+    capsules: AxisCapsule[];
+}
+interface ActorKeyRecord {
+    id: Buffer;
+    actor_id: string;
+    key_id: string;
+    algorithm: string;
+    public_key: Buffer;
+    purpose: string;
+    status: KeyStatus;
+    is_primary: boolean;
+    not_before: Date | null;
+    expires_at: Date | null;
+    rotated_from_key_id: string | null;
+    revoked_at: Date | null;
+    revocation_reason: string | null;
+    metadata: any;
+    created_at: Date;
+    updated_at: Date;
+}
+interface IssuerKeyRecord {
+    id: Buffer;
+    kid: string;
+    issuer_id: string;
+    alg: string;
+    public_key_pem: string;
+    status: KeyStatus;
+    not_before: Date | null;
+    not_after: Date | null;
+    fingerprint: string | null;
+    metadata: any;
+    created_at: Date;
+    updated_at: Date;
+}
+interface CapsuleRecord {
+    id: Buffer;
+    capsule_id: string;
+    actor_id: string;
+    intent: string;
+    audience: string;
+    issuer: string;
+    subject: string | null;
+    status: CapsuleStatus;
+    mode: CapsuleMode;
+    max_uses: number;
+    used_count: number;
+    iat: Date;
+    nbf: Date | null;
+    exp: Date;
+    scopes_json: any;
+    constraints_json: any;
+    policy_refs_json: any;
+    risk_score: number | null;
+    payload_hash: Buffer;
+    sig_alg: string;
+    sig_kid: string;
+    sig_value: Buffer;
+    created_at: Date;
+    updated_at: Date;
+    last_used_at: Date | null;
+}
 
 declare class ContractViolationError extends Error {
     code: string;
@@ -527,7 +674,7 @@ type AxisAlg = Extract<AxisAlg$1, 'EdDSA'>;
 type AxisSig = AxisSig$1 & {
     alg: AxisAlg;
 };
-interface AxisFrame<T = any> {
+interface AxisFrame$1<T = any> {
     v: 1;
     pid: string;
     nonce: string;
@@ -758,4 +905,1356 @@ interface IntentDefinition {
 declare function validateFrameShape(frame: any): boolean;
 declare function isTimestampValid(ts: number, skewSeconds?: number): boolean;
 
-export { ATS1_HDR, ATS1_SCHEMA, AXIS_OPCODES, ats1 as Ats1Codec, type Axis1DecodedFrame, type Axis1FrameToEncode, type AxisAlg$1 as AxisAlg, type AxisPacket as AxisBinaryPacket, type AxisCapsuleConstraints, type AxisCapsulePayload, type AxisCrudHandler, type AxisEffect, type AxisHandler, type AxisHandlerInit, AxisIdDto, type AxisAlg as AxisJsonAlg, type AxisFrame as AxisJsonFrame, type AxisResponse as AxisJsonResponse, type AxisSig as AxisJsonSig, type AxisObservedContext, type AxisPacket$1 as AxisPacket, T as AxisPacketTags, AxisPartialType, type AxisPostSensor, type AxisPreSensor, type AxisRequestContext, AxisResponseDto, type AxisSensor, type AxisSensorInit, type AxisSig$1 as AxisSig, AxisTlvDto, CAPABILITIES, type Capability, type CapsuleMode, ContractViolationError, DEFAULT_CONTRACTS, DEFAULT_TIMEOUT, Decision, type DtoSchema, type ExecutionContract, ExecutionMeter, type ExecutionMetrics, FALLBACK_CONTRACT, HANDLER_METADATA_KEY, Handler, INTENT_METADATA_KEY, INTENT_REQUIREMENTS, INTENT_ROUTES_KEY, INTENT_SENSITIVITY_MAP, INTENT_TIMEOUTS, Intent, type IntentDefinition, type IntentKind, type IntentOptions, type IntentRoute, IntentRouter, IntentSensitivity, type IntentTlvField, type KeyStatus, PROOF_CAPABILITIES, RESPONSE_TAG_CREATED_AT, RESPONSE_TAG_CREATED_BY, RESPONSE_TAG_ID, RESPONSE_TAG_UPDATED_AT, RESPONSE_TAG_UPDATED_BY, type ReceiptEffect, RiskDecision, type RiskEvaluation, type RiskSignal, Schema2002_PasskeyLoginOptionsRes, Schema2011_PasskeyLoginVerifyReq, Schema2012_PasskeyLoginVerifyRes, Schema2021_PasskeyRegisterOptionsReq, type SensorDecision, SensorDecisions, type SensorInput, type SensorMinifiedDecision, type SensorPhaseMetadata, TLV_FIELDS_KEY, TLV_VALIDATORS_KEY, TlvEnum, TlvField, type TlvFieldKind, type TlvFieldMeta, type TlvFieldOptions, TlvMinLen, TlvRange, TlvUtf8Pattern, TlvValidate, type TlvValidatorFn, type TlvValidatorMeta, axis1SigningBytes, b64urlDecode, b64urlDecodeString, b64urlEncode, b64urlEncodeString, buildAts1Hdr, buildDtoDecoder, buildPacket, buildReceiptHash, buildTLVs, bytes, canAccessResource, canonicalJson, canonicalJsonExcluding, classifyIntent, decodeAxis1Frame, encVarint, encodeAxis1Frame, extractDtoSchema, hasScope, isAdminOpcode, isKnownOpcode, isTimestampValid, nonce16, normalizeSensorDecision, packPasskeyLoginOptionsReq, packPasskeyLoginOptionsRes, packPasskeyLoginVerifyReq, packPasskeyLoginVerifyRes, packPasskeyRegisterOptionsReq, parseScope, resolveTimeout, sensitivityName, tlv, u64be, unpackPasskeyLoginOptionsReq, unpackPasskeyLoginVerifyReq, unpackPasskeyRegisterOptionsReq, utf8, validateFrameShape, varintU };
+type UploadSessionStatus = 'ACTIVE' | 'FINALIZING' | 'COMPLETE' | 'ABORTED';
+interface UploadSessionRecord {
+    id?: string;
+    fileId: string;
+    filename?: string;
+    status: UploadSessionStatus | string;
+    totalSize?: number;
+    chunkSize?: number;
+    totalChunks?: number;
+    receivedBitmap?: Uint8Array | Buffer | null;
+    hashState?: Uint8Array | Buffer | null;
+    mimeType?: string | null;
+    version?: number;
+}
+interface UploadSessionStore {
+    findByFileId(fileId: string): Promise<UploadSessionRecord | null>;
+    updateStatus(fileId: string, status: UploadSessionStatus, hashState?: Uint8Array | Buffer | null): Promise<void>;
+}
+interface UploadReceiptSigner {
+    signActive(message: Uint8Array): {
+        kid: string;
+        sig: Uint8Array;
+    };
+}
+interface UploadFileStat {
+    path: string;
+    size: number;
+}
+interface UploadFileStore {
+    getFinalPath(fileId: string, filename?: string): string;
+    getTempPath(fileId: string): string;
+    statFinal(fileId: string, filename?: string): Promise<UploadFileStat>;
+    readFinalRange(fileId: string, filename: string | undefined, start: number, length: number): Promise<Buffer>;
+    hasTemp(fileId: string): Promise<boolean>;
+    moveTempToFinal(fileId: string, filename?: string): Promise<string>;
+    createTempReadStream(fileId: string): NodeJS.ReadableStream;
+}
+
+declare class AxisFilesDownloadHandler implements AxisHandler {
+    private readonly sessions;
+    private readonly files;
+    private readonly logger;
+    readonly name = "axis.files.download";
+    readonly open = true;
+    readonly description = "File download handler";
+    constructor(sessions: UploadSessionStore, files: UploadFileStore);
+    execute(body: Uint8Array, headers?: Map<number, Uint8Array>): Promise<any>;
+}
+declare class AxisFilesFinalizeHandler implements AxisHandler {
+    private readonly sessions;
+    private readonly files;
+    private readonly keyring?;
+    private readonly logger;
+    readonly name = "axis.files.finalize";
+    readonly open = false;
+    readonly description = "File upload finalization handler";
+    constructor(sessions: UploadSessionStore, files: UploadFileStore, keyring?: UploadReceiptSigner | undefined);
+    execute(body: Uint8Array, headers?: Map<number, Uint8Array>): Promise<any>;
+}
+
+declare const AXIS_UPLOAD_SESSION_STORE = "AXIS_UPLOAD_SESSION_STORE";
+declare const AXIS_UPLOAD_FILE_STORE = "AXIS_UPLOAD_FILE_STORE";
+declare const AXIS_UPLOAD_RECEIPT_SIGNER = "AXIS_UPLOAD_RECEIPT_SIGNER";
+
+interface DiskUploadFileStoreOptions {
+    uploadDir: string;
+    chunkDir: string;
+}
+declare class DiskUploadFileStore implements UploadFileStore {
+    private readonly uploadDir;
+    private readonly chunkDir;
+    constructor(options: DiskUploadFileStoreOptions);
+    getFinalPath(fileId: string, filename?: string): string;
+    getTempPath(fileId: string): string;
+    statFinal(fileId: string, filename?: string): Promise<UploadFileStat>;
+    readFinalRange(fileId: string, filename: string | undefined, start: number, length: number): Promise<Buffer>;
+    hasTemp(fileId: string): Promise<boolean>;
+    moveTempToFinal(fileId: string, filename?: string): Promise<string>;
+    createTempReadStream(fileId: string): NodeJS.ReadableStream;
+}
+
+type ProofType$1 = 1 | 2 | 3 | 4;
+interface ProofVerificationResult {
+    valid: boolean;
+    actorId?: string;
+    error?: string;
+    metadata?: Record<string, any>;
+}
+interface MTLSContext {
+    clientCertPem?: string;
+    clientCertFingerprint?: string;
+    clientCertSubject?: string;
+    clientCertIssuer?: string;
+    verified?: boolean;
+}
+interface DeviceSEContext {
+    deviceId: string;
+    signature: Uint8Array;
+    publicKey: Uint8Array;
+    challenge?: Uint8Array;
+}
+declare class ProofVerificationService {
+    private readonly logger;
+    private readonly deviceKeys;
+    private readonly trustedCerts;
+    verifyProof(proofType: ProofType$1, proofRef: Uint8Array, context: {
+        signTarget?: Uint8Array;
+        signature?: Uint8Array;
+        mtls?: MTLSContext;
+        deviceSE?: DeviceSEContext;
+    }): Promise<ProofVerificationResult>;
+    private verifyCapsuleProof;
+    private verifyJWTProof;
+    private verifyMTLSProof;
+    private verifyDeviceSEProof;
+    registerDeviceKey(deviceId: string, publicKey: Uint8Array): void;
+    unregisterDevice(deviceId: string): boolean;
+    registerMTLSCert(fingerprint: string, actorId: string): void;
+    revokeMTLSCert(fingerprint: string): boolean;
+    static calculateFingerprint(certPem: string): string;
+}
+
+type index$7_ActorKeyRecord = ActorKeyRecord;
+type index$7_AxisCapsule = AxisCapsule;
+type index$7_AxisCapsuleConstraints = AxisCapsuleConstraints;
+type index$7_AxisCapsulePayload = AxisCapsulePayload;
+type index$7_CapsuleBatchBody = CapsuleBatchBody;
+type index$7_CapsuleBatchResult = CapsuleBatchResult;
+type index$7_CapsuleIssueBody = CapsuleIssueBody;
+type index$7_CapsuleIssueResult = CapsuleIssueResult;
+type index$7_CapsuleMode = CapsuleMode;
+type index$7_CapsuleRecord = CapsuleRecord;
+type index$7_CapsuleRevokeBody = CapsuleRevokeBody;
+type index$7_CapsuleStatus = CapsuleStatus;
+type index$7_DeviceSEContext = DeviceSEContext;
+type index$7_IntentExecBody = IntentExecBody;
+type index$7_IssuerKeyRecord = IssuerKeyRecord;
+type index$7_KeyStatus = KeyStatus;
+type index$7_MTLSContext = MTLSContext;
+type index$7_ProofVerificationResult = ProofVerificationResult;
+type index$7_ProofVerificationService = ProofVerificationService;
+declare const index$7_ProofVerificationService: typeof ProofVerificationService;
+type index$7_TickWindow = TickWindow;
+declare const index$7_b64urlDecode: typeof b64urlDecode;
+declare const index$7_b64urlDecodeString: typeof b64urlDecodeString;
+declare const index$7_b64urlEncode: typeof b64urlEncode;
+declare const index$7_b64urlEncodeString: typeof b64urlEncodeString;
+declare const index$7_canonicalJson: typeof canonicalJson;
+declare const index$7_canonicalJsonExcluding: typeof canonicalJsonExcluding;
+declare namespace index$7 {
+  export { type index$7_ActorKeyRecord as ActorKeyRecord, type AxisAlg$1 as AxisAlg, type index$7_AxisCapsule as AxisCapsule, type index$7_AxisCapsuleConstraints as AxisCapsuleConstraints, type index$7_AxisCapsulePayload as AxisCapsulePayload, type AxisPacket$1 as AxisPacket, type AxisResponse$1 as AxisResponse, type AxisSig$1 as AxisSig, type index$7_CapsuleBatchBody as CapsuleBatchBody, type index$7_CapsuleBatchResult as CapsuleBatchResult, type index$7_CapsuleIssueBody as CapsuleIssueBody, type index$7_CapsuleIssueResult as CapsuleIssueResult, type index$7_CapsuleMode as CapsuleMode, type index$7_CapsuleRecord as CapsuleRecord, type index$7_CapsuleRevokeBody as CapsuleRevokeBody, type index$7_CapsuleStatus as CapsuleStatus, type index$7_DeviceSEContext as DeviceSEContext, type index$7_IntentExecBody as IntentExecBody, type index$7_IssuerKeyRecord as IssuerKeyRecord, type index$7_KeyStatus as KeyStatus, type index$7_MTLSContext as MTLSContext, type ProofType$1 as ProofType, type index$7_ProofVerificationResult as ProofVerificationResult, index$7_ProofVerificationService as ProofVerificationService, type index$7_TickWindow as TickWindow, index$7_b64urlDecode as b64urlDecode, index$7_b64urlDecodeString as b64urlDecodeString, index$7_b64urlEncode as b64urlEncode, index$7_b64urlEncodeString as b64urlEncodeString, index$7_canonicalJson as canonicalJson, index$7_canonicalJsonExcluding as canonicalJsonExcluding };
+}
+
+interface AxisRequestData {
+    raw: Buffer;
+    ip: string | undefined;
+    preDecodeInput: any;
+    frameBytesCount: number;
+}
+declare const AxisRaw: (...dataOrPipes: unknown[]) => ParameterDecorator;
+declare const AxisIp: (...dataOrPipes: unknown[]) => ParameterDecorator;
+declare const AxisContext$1: (...dataOrPipes: unknown[]) => ParameterDecorator;
+declare const AxisDemoPubkey: (...dataOrPipes: unknown[]) => ParameterDecorator;
+declare const AxisFrame: (...dataOrPipes: unknown[]) => ParameterDecorator;
+
+declare const SENSOR_METADATA_KEY = "axis:sensor";
+type SensorPhase = 'PRE_DECODE' | 'POST_DECODE';
+interface SensorOptions {
+    phase?: SensorPhase;
+}
+declare function Sensor(options?: SensorOptions): ClassDecorator;
+
+declare const index$6_AxisDemoPubkey: typeof AxisDemoPubkey;
+declare const index$6_AxisFrame: typeof AxisFrame;
+declare const index$6_AxisIp: typeof AxisIp;
+declare const index$6_AxisRaw: typeof AxisRaw;
+type index$6_AxisRequestData = AxisRequestData;
+type index$6_DtoSchema = DtoSchema;
+declare const index$6_HANDLER_METADATA_KEY: typeof HANDLER_METADATA_KEY;
+declare const index$6_Handler: typeof Handler;
+declare const index$6_INTENT_BODY_KEY: typeof INTENT_BODY_KEY;
+declare const index$6_INTENT_METADATA_KEY: typeof INTENT_METADATA_KEY;
+declare const index$6_INTENT_ROUTES_KEY: typeof INTENT_ROUTES_KEY;
+declare const index$6_INTENT_SENSORS_KEY: typeof INTENT_SENSORS_KEY;
+declare const index$6_Intent: typeof Intent;
+declare const index$6_IntentBody: typeof IntentBody;
+type index$6_IntentKind = IntentKind;
+type index$6_IntentOptions = IntentOptions;
+type index$6_IntentRoute = IntentRoute;
+declare const index$6_IntentSensors: typeof IntentSensors;
+type index$6_IntentTlvField = IntentTlvField;
+declare const index$6_SENSOR_METADATA_KEY: typeof SENSOR_METADATA_KEY;
+declare const index$6_Sensor: typeof Sensor;
+type index$6_SensorOptions = SensorOptions;
+type index$6_SensorPhase = SensorPhase;
+declare const index$6_TLV_FIELDS_KEY: typeof TLV_FIELDS_KEY;
+declare const index$6_TLV_VALIDATORS_KEY: typeof TLV_VALIDATORS_KEY;
+declare const index$6_TlvEnum: typeof TlvEnum;
+declare const index$6_TlvField: typeof TlvField;
+type index$6_TlvFieldKind = TlvFieldKind;
+type index$6_TlvFieldMeta = TlvFieldMeta;
+type index$6_TlvFieldOptions = TlvFieldOptions;
+declare const index$6_TlvMinLen: typeof TlvMinLen;
+declare const index$6_TlvRange: typeof TlvRange;
+declare const index$6_TlvUtf8Pattern: typeof TlvUtf8Pattern;
+declare const index$6_TlvValidate: typeof TlvValidate;
+type index$6_TlvValidatorFn = TlvValidatorFn;
+type index$6_TlvValidatorMeta = TlvValidatorMeta;
+declare const index$6_buildDtoDecoder: typeof buildDtoDecoder;
+declare const index$6_extractDtoSchema: typeof extractDtoSchema;
+declare namespace index$6 {
+  export { AxisContext$1 as AxisContext, index$6_AxisDemoPubkey as AxisDemoPubkey, index$6_AxisFrame as AxisFrame, index$6_AxisIp as AxisIp, index$6_AxisRaw as AxisRaw, type index$6_AxisRequestData as AxisRequestData, type index$6_DtoSchema as DtoSchema, index$6_HANDLER_METADATA_KEY as HANDLER_METADATA_KEY, index$6_Handler as Handler, index$6_INTENT_BODY_KEY as INTENT_BODY_KEY, index$6_INTENT_METADATA_KEY as INTENT_METADATA_KEY, index$6_INTENT_ROUTES_KEY as INTENT_ROUTES_KEY, index$6_INTENT_SENSORS_KEY as INTENT_SENSORS_KEY, index$6_Intent as Intent, index$6_IntentBody as IntentBody, type index$6_IntentKind as IntentKind, type index$6_IntentOptions as IntentOptions, type index$6_IntentRoute as IntentRoute, index$6_IntentSensors as IntentSensors, type index$6_IntentTlvField as IntentTlvField, index$6_SENSOR_METADATA_KEY as SENSOR_METADATA_KEY, index$6_Sensor as Sensor, type index$6_SensorOptions as SensorOptions, type index$6_SensorPhase as SensorPhase, index$6_TLV_FIELDS_KEY as TLV_FIELDS_KEY, index$6_TLV_VALIDATORS_KEY as TLV_VALIDATORS_KEY, index$6_TlvEnum as TlvEnum, index$6_TlvField as TlvField, type index$6_TlvFieldKind as TlvFieldKind, type index$6_TlvFieldMeta as TlvFieldMeta, type index$6_TlvFieldOptions as TlvFieldOptions, index$6_TlvMinLen as TlvMinLen, index$6_TlvRange as TlvRange, index$6_TlvUtf8Pattern as TlvUtf8Pattern, index$6_TlvValidate as TlvValidate, type index$6_TlvValidatorFn as TlvValidatorFn, type index$6_TlvValidatorMeta as TlvValidatorMeta, index$6_buildDtoDecoder as buildDtoDecoder, index$6_extractDtoSchema as extractDtoSchema };
+}
+
+declare const SensorDecisionZ: z.ZodUnion<readonly [z.ZodObject<{
+    action: z.ZodLiteral<"ALLOW">;
+    meta: z.ZodOptional<z.ZodAny>;
+}, z.core.$strip>, z.ZodObject<{
+    action: z.ZodLiteral<"DENY">;
+    code: z.ZodString;
+    reason: z.ZodOptional<z.ZodString>;
+    meta: z.ZodOptional<z.ZodAny>;
+}, z.core.$strip>]>;
+declare const SensorDecisionWithMetadataZ: z.ZodUnion<readonly [z.ZodObject<{
+    action: z.ZodLiteral<"ALLOW">;
+    meta: z.ZodOptional<z.ZodAny>;
+}, z.core.$strip>, z.ZodObject<{
+    action: z.ZodLiteral<"DENY">;
+    code: z.ZodString;
+    reason: z.ZodOptional<z.ZodString>;
+    retryAfterMs: z.ZodOptional<z.ZodNumber>;
+    meta: z.ZodOptional<z.ZodAny>;
+}, z.core.$strip>]>;
+declare const CountryBlockSensorInputZ: z.ZodObject<{
+    ip: z.ZodString;
+    country: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type CountryBlockSensorInput = z.infer<typeof CountryBlockSensorInputZ>;
+declare const CountryBlockDecisionZ: z.ZodUnion<readonly [z.ZodObject<{
+    action: z.ZodLiteral<"ALLOW">;
+    meta: z.ZodOptional<z.ZodAny>;
+}, z.core.$strip>, z.ZodObject<{
+    action: z.ZodLiteral<"DENY">;
+    code: z.ZodString;
+    reason: z.ZodOptional<z.ZodString>;
+    meta: z.ZodOptional<z.ZodAny>;
+}, z.core.$strip>]>;
+type CountryBlockDecision = z.infer<typeof CountryBlockDecisionZ>;
+declare const ScanBurstSensorInputZ: z.ZodObject<{
+    ip: z.ZodString;
+    isFailure: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+type ScanBurstSensorInput = z.infer<typeof ScanBurstSensorInputZ>;
+declare const ScanBurstDecisionZ: z.ZodUnion<readonly [z.ZodObject<{
+    action: z.ZodLiteral<"ALLOW">;
+    meta: z.ZodOptional<z.ZodAny>;
+}, z.core.$strip>, z.ZodObject<{
+    action: z.ZodLiteral<"DENY">;
+    code: z.ZodString;
+    reason: z.ZodOptional<z.ZodString>;
+    retryAfterMs: z.ZodOptional<z.ZodNumber>;
+    meta: z.ZodOptional<z.ZodAny>;
+}, z.core.$strip>]>;
+type ScanBurstDecision = z.infer<typeof ScanBurstDecisionZ>;
+declare const ProofKindZ: z.ZodEnum<{
+    NONE: "NONE";
+    CAPSULE: "CAPSULE";
+    PASSPORT: "PASSPORT";
+    MTLS: "MTLS";
+    JWT: "JWT";
+}>;
+type ProofKind = z.infer<typeof ProofKindZ>;
+declare const AccessProfileZ: z.ZodEnum<{
+    PUBLIC: "PUBLIC";
+    PARTNER: "PARTNER";
+    INTERNAL: "INTERNAL";
+    NODE: "NODE";
+}>;
+type AccessProfile = z.infer<typeof AccessProfileZ>;
+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.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 const IntentPolicyZ: z.ZodObject<{
+    intent: z.ZodString;
+    sensitivity: z.ZodEnum<{
+        LOW: "LOW";
+        MEDIUM: "MEDIUM";
+        HIGH: "HIGH";
+        CRITICAL: "CRITICAL";
+    }>;
+    maxFrameBytes: z.ZodNumber;
+    maxHeaderBytes: z.ZodNumber;
+    maxBodyBytes: z.ZodNumber;
+    maxSigBytes: z.ZodOptional<z.ZodNumber>;
+    rateLimitPerMinute: z.ZodOptional<z.ZodNumber>;
+    rateLimitPerHour: z.ZodOptional<z.ZodNumber>;
+    requiresSignature: z.ZodBoolean;
+    requiresCapsule: z.ZodBoolean;
+    timeoutMs: z.ZodNumber;
+}, z.core.$strip>;
+type IntentPolicy = z.infer<typeof IntentPolicyZ>;
+declare const IntentPolicySensorInputZ: z.ZodObject<{
+    frame: z.ZodObject<{
+        flags: z.ZodNumber;
+        headers: z.ZodMap<z.ZodNumber, z.ZodCustom<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>>>;
+        body: z.ZodCustom<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>>;
+        sig: z.ZodCustom<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>>;
+    }, z.core.$strip>;
+    intent: z.ZodString;
+    rawFrameSize: z.ZodNumber;
+}, z.core.$strip>;
+type IntentPolicySensorInput = z.infer<typeof IntentPolicySensorInputZ>;
+declare const IntentPolicyDecisionZ: z.ZodUnion<readonly [z.ZodObject<{
+    action: z.ZodLiteral<"ALLOW">;
+    policy: z.ZodObject<{
+        intent: z.ZodString;
+        sensitivity: z.ZodEnum<{
+            LOW: "LOW";
+            MEDIUM: "MEDIUM";
+            HIGH: "HIGH";
+            CRITICAL: "CRITICAL";
+        }>;
+        maxFrameBytes: z.ZodNumber;
+        maxHeaderBytes: z.ZodNumber;
+        maxBodyBytes: z.ZodNumber;
+        maxSigBytes: z.ZodOptional<z.ZodNumber>;
+        rateLimitPerMinute: z.ZodOptional<z.ZodNumber>;
+        rateLimitPerHour: z.ZodOptional<z.ZodNumber>;
+        requiresSignature: z.ZodBoolean;
+        requiresCapsule: z.ZodBoolean;
+        timeoutMs: z.ZodNumber;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    action: z.ZodLiteral<"DENY">;
+    reason: z.ZodString;
+}, z.core.$strip>]>;
+type IntentPolicyDecision = z.infer<typeof IntentPolicyDecisionZ>;
+declare const CapsuleClaimsZ: z.ZodObject<{
+    capsuleId: z.ZodString;
+    allowIntents: z.ZodArray<z.ZodString>;
+    limits: z.ZodOptional<z.ZodObject<{
+        maxBodyBytes: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    scopes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+}, z.core.$strip>;
+type CapsuleClaims = z.infer<typeof CapsuleClaimsZ>;
+declare const CapsuleZ: 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.core.$strip>>;
+        scopes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    }, z.core.$strip>;
+    issuedAt: z.ZodNumber;
+    expiresAt: z.ZodNumber;
+    tier: z.ZodEnum<{
+        FREE: "FREE";
+        STANDARD: "STANDARD";
+        PREMIUM: "PREMIUM";
+    }>;
+}, z.core.$strip>;
+type Capsule = z.infer<typeof CapsuleZ>;
+declare const CapsuleValidationResultZ: z.ZodObject<{
+    valid: z.ZodBoolean;
+    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.core.$strip>>;
+            scopes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+        }, z.core.$strip>;
+        issuedAt: z.ZodNumber;
+        expiresAt: z.ZodNumber;
+        tier: z.ZodEnum<{
+            FREE: "FREE";
+            STANDARD: "STANDARD";
+            PREMIUM: "PREMIUM";
+        }>;
+    }, z.core.$strip>>;
+    reason: z.ZodOptional<z.ZodString>;
+    requiresStepUp: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+type CapsuleValidationResult = z.infer<typeof CapsuleValidationResultZ>;
+declare const CapsuleVerifySensorInputZ: z.ZodObject<{
+    headers: z.ZodMap<z.ZodNumber, z.ZodCustom<Uint8Array<ArrayBufferLike>, Uint8Array<ArrayBufferLike>>>;
+    intent: z.ZodString;
+    ctx: z.ZodAny;
+}, z.core.$strip>;
+type CapsuleVerifySensorInput = z.infer<typeof CapsuleVerifySensorInputZ>;
+declare const CapsuleVerifyResultZ: z.ZodObject<{
+    ok: z.ZodLiteral<true>;
+    capsule: 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.core.$strip>>;
+            scopes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+        }, z.core.$strip>;
+        issuedAt: z.ZodNumber;
+        expiresAt: z.ZodNumber;
+        tier: z.ZodEnum<{
+            FREE: "FREE";
+            STANDARD: "STANDARD";
+            PREMIUM: "PREMIUM";
+        }>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+type CapsuleVerifyResult = z.infer<typeof CapsuleVerifyResultZ>;
+declare const RateLimitProfileZ: z.ZodEnum<{
+    PUBLIC: "PUBLIC";
+    PARTNER: "PARTNER";
+    INTERNAL: "INTERNAL";
+    NODE: "NODE";
+}>;
+type RateLimitProfile = z.infer<typeof RateLimitProfileZ>;
+declare const RateLimitInputZ: z.ZodObject<{
+    ip: z.ZodString;
+    userAgent: z.ZodOptional<z.ZodString>;
+    actorId: z.ZodOptional<z.ZodString>;
+    capsuleId: z.ZodOptional<z.ZodString>;
+    intent: z.ZodString;
+    profile: z.ZodEnum<{
+        PUBLIC: "PUBLIC";
+        PARTNER: "PARTNER";
+        INTERNAL: "INTERNAL";
+        NODE: "NODE";
+    }>;
+}, z.core.$strip>;
+type RateLimitInput = z.infer<typeof RateLimitInputZ>;
+declare const RateLimitConfigZ: z.ZodObject<{
+    windowSec: z.ZodNumber;
+    max: z.ZodNumber;
+    key: z.ZodEnum<{
+        ip_fingerprint: "ip_fingerprint";
+        actor_capsule: "actor_capsule";
+    }>;
+}, z.core.$strip>;
+type RateLimitConfig = z.infer<typeof RateLimitConfigZ>;
+declare const SensorResultZ: z.ZodObject<{
+    ok: z.ZodLiteral<true>;
+}, z.core.$strip>;
+type SensorResult = z.infer<typeof SensorResultZ>;
+declare const PassportZ: 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.core.$strip>;
+declare const ExecutionMetricsZ: z.ZodObject<{
+    dbWrites: z.ZodNumber;
+    dbReads: z.ZodNumber;
+    externalCalls: z.ZodNumber;
+    elapsedMs: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strip>;
+type Passport = z.infer<typeof PassportZ>;
+declare const SensorChainInputZ: z.ZodObject<{
+    ip: z.ZodString;
+    path: z.ZodString;
+    contentLength: z.ZodNumber;
+    peek: z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>;
+    country: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type SensorChainInput = z.infer<typeof SensorChainInputZ>;
+declare const EntropySensorInputZ: z.ZodObject<{
+    pid: z.ZodOptional<z.ZodCustom<Buffer<ArrayBufferLike>, Buffer<ArrayBufferLike>>>;
+    nonce: z.ZodOptional<z.ZodCustom<Buffer<ArrayBufferLike>, Buffer<ArrayBufferLike>>>;
+    ip: z.ZodString;
+}, z.core.$strip>;
+type EntropySensorInput = z.infer<typeof EntropySensorInputZ>;
+declare const ProtocolStrictInputZ: z.ZodObject<{
+    rawBytes: z.ZodOptional<z.ZodUnion<readonly [z.ZodCustom<Buffer<ArrayBufferLike>, Buffer<ArrayBufferLike>>, z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>]>>;
+    ip: z.ZodString;
+    path: z.ZodString;
+    contentLength: z.ZodNumber;
+    peek: z.ZodCustom<Uint8Array<ArrayBuffer>, Uint8Array<ArrayBuffer>>;
+    country: z.ZodOptional<z.ZodString>;
+    contentType: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type ProtocolStrictInput = z.infer<typeof ProtocolStrictInputZ>;
+declare const SchemaFieldKindZ: z.ZodEnum<{
+    utf8: "utf8";
+    u64: "u64";
+    bytes: "bytes";
+    bytes16: "bytes16";
+    bool: "bool";
+    obj: "obj";
+    arr: "arr";
+}>;
+type SchemaFieldKind = z.infer<typeof SchemaFieldKindZ>;
+declare const ScopeZ: z.ZodEnum<{
+    header: "header";
+    body: "body";
+}>;
+type Scope = z.infer<typeof ScopeZ>;
+declare const SchemaFieldZ: z.ZodObject<{
+    name: z.ZodString;
+    tlv: z.ZodNumber;
+    kind: z.ZodEnum<{
+        utf8: "utf8";
+        u64: "u64";
+        bytes: "bytes";
+        bytes16: "bytes16";
+        bool: "bool";
+        obj: "obj";
+        arr: "arr";
+    }>;
+    required: z.ZodOptional<z.ZodBoolean>;
+    maxLen: z.ZodOptional<z.ZodNumber>;
+    max: z.ZodOptional<z.ZodString>;
+    scope: z.ZodOptional<z.ZodEnum<{
+        header: "header";
+        body: "body";
+    }>>;
+}, z.core.$strip>;
+type SchemaField = z.infer<typeof SchemaFieldZ>;
+declare const BodyProfileZ: z.ZodEnum<{
+    TLV_MAP: "TLV_MAP";
+    RAW: "RAW";
+    TLV_OBJ: "TLV_OBJ";
+    TLV_ARR: "TLV_ARR";
+}>;
+declare const IntentSchemaZ: z.ZodObject<{
+    intent: z.ZodString;
+    version: z.ZodNumber;
+    bodyProfile: z.ZodEnum<{
+        TLV_MAP: "TLV_MAP";
+        RAW: "RAW";
+        TLV_OBJ: "TLV_OBJ";
+        TLV_ARR: "TLV_ARR";
+    }>;
+    fields: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        tlv: z.ZodNumber;
+        kind: z.ZodEnum<{
+            utf8: "utf8";
+            u64: "u64";
+            bytes: "bytes";
+            bytes16: "bytes16";
+            bool: "bool";
+            obj: "obj";
+            arr: "arr";
+        }>;
+        required: z.ZodOptional<z.ZodBoolean>;
+        maxLen: z.ZodOptional<z.ZodNumber>;
+        max: z.ZodOptional<z.ZodString>;
+        scope: z.ZodOptional<z.ZodEnum<{
+            header: "header";
+            body: "body";
+        }>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+type IntentSchema = z.infer<typeof IntentSchemaZ>;
+declare const WsHandshakeInputZ: z.ZodObject<{
+    clientId: z.ZodString;
+    isWs: z.ZodBoolean;
+    ip: z.ZodString;
+}, z.core.$strip>;
+type WsHandshakeInput = z.infer<typeof WsHandshakeInputZ>;
+declare const WsHandshakeDecisionZ: z.ZodUnion<readonly [z.ZodObject<{
+    action: z.ZodLiteral<"ALLOW">;
+}, z.core.$strip>, z.ZodObject<{
+    action: z.ZodLiteral<"DENY">;
+    code: z.ZodString;
+}, z.core.$strip>]>;
+type WsHandshakeDecision = z.infer<typeof WsHandshakeDecisionZ>;
+declare const IPReputationInputZ: z.ZodObject<{
+    ip: z.ZodString;
+}, z.core.$strip>;
+type IPReputationInput = z.infer<typeof IPReputationInputZ>;
+declare const IPReputationZ: z.ZodObject<{
+    score: z.ZodNumber;
+    lastUpdated: z.ZodNumber;
+    totalRequests: z.ZodNumber;
+    failedRequests: z.ZodNumber;
+    blockedRequests: z.ZodNumber;
+    tags: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+type IPReputation = z.infer<typeof IPReputationZ>;
+declare const UploadStatusZ: z.ZodEnum<{
+    FINALIZING: "FINALIZING";
+    ABORTED: "ABORTED";
+    INIT: "INIT";
+    UPLOADING: "UPLOADING";
+    DONE: "DONE";
+}>;
+type UploadStatus = z.infer<typeof UploadStatusZ>;
+declare const UploadSessionZ: z.ZodObject<{
+    uploadIdHex: z.ZodString;
+    fileName: z.ZodString;
+    totalSize: z.ZodNumber;
+    chunkSize: z.ZodNumber;
+    totalChunks: z.ZodNumber;
+    receivedCount: z.ZodNumber;
+    status: z.ZodEnum<{
+        FINALIZING: "FINALIZING";
+        ABORTED: "ABORTED";
+        INIT: "INIT";
+        UPLOADING: "UPLOADING";
+        DONE: "DONE";
+    }>;
+}, z.core.$strip>;
+type UploadSession = z.infer<typeof UploadSessionZ>;
+declare const BodyBudgetInputZ: z.ZodObject<{
+    intent: z.ZodString;
+    headerLen: z.ZodNumber;
+    bodyLen: z.ZodNumber;
+}, z.core.$strip>;
+type BodyBudgetInput = z.infer<typeof BodyBudgetInputZ>;
+declare const BodyBudgetPolicyZ: z.ZodObject<{
+    maxHeaderBytes: z.ZodNumber;
+    maxBodyBytes: z.ZodNumber;
+}, z.core.$strip>;
+type BodyBudgetPolicy = z.infer<typeof BodyBudgetPolicyZ>;
+declare const ChunkHashInputZ: z.ZodObject<{
+    headerTLVs: z.ZodAny;
+    bodyBytes: z.ZodAny;
+    intent: z.ZodString;
+}, z.core.$strip>;
+type ChunkHashInput = z.infer<typeof ChunkHashInputZ>;
+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.core.$strip>>;
+            scopes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+        }, z.core.$strip>;
+        issuedAt: z.ZodNumber;
+        expiresAt: z.ZodNumber;
+        tier: z.ZodEnum<{
+            FREE: "FREE";
+            STANDARD: "STANDARD";
+            PREMIUM: "PREMIUM";
+        }>;
+    }, 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.core.$strip>>;
+    meter: z.ZodOptional<z.ZodAny>;
+}, z.core.$strip>;
+type AxisContext = z.infer<typeof AxisContextZ>;
+declare const AxisErrorZ: z.ZodObject<{
+    code: z.ZodString;
+    message: z.ZodString;
+    httpStatus: z.ZodNumber;
+}, z.core.$strip>;
+type AxisError = z.infer<typeof AxisErrorZ>;
+
+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;
+
+interface AxisDecoded {
+    frame: Axis1DecodedFrame;
+    packet: AxisPacket;
+    axisCtx: AxisContext;
+    correlationId: Buffer;
+    correlationIdHex: string;
+    sensorInput: SensorInput;
+    extra: {
+        ip?: string;
+        demoPubkeyHex?: string;
+    };
+    observation: AxisObservation;
+}
+
+declare class HandlerDiscoveryService implements OnModuleInit {
+    private readonly discovery;
+    private readonly scanner;
+    private readonly router;
+    private readonly logger;
+    constructor(discovery: DiscoveryService, scanner: MetadataScanner, router: IntentRouter);
+    onModuleInit(): void;
+}
+
+declare const BAND: {
+    readonly WIRE: 0;
+    readonly IDENTITY: 40;
+    readonly POLICY: 90;
+    readonly CONTENT: 140;
+    readonly BUSINESS: 200;
+    readonly AUDIT: 900;
+};
+type SensorBand = keyof typeof BAND;
+declare const PRE_DECODE_BOUNDARY = 40;
+
+declare class SensorRegistry {
+    private readonly configService;
+    private sensors;
+    private readonly logger;
+    constructor(configService: ConfigService);
+    register(sensor: AxisSensor): void;
+    list(): AxisSensor[];
+    getPreDecodeSensors(): AxisPreSensor[];
+    getPostDecodeSensors(): AxisPostSensor[];
+    private isPreDecodeSensor;
+    private isPostDecodeSensor;
+    getSensorCountByPhase(): {
+        preDecodeCount: number;
+        postDecodeCount: number;
+    };
+    clear(): void;
+}
+
+declare class SensorDiscoveryService implements OnApplicationBootstrap {
+    private readonly discovery;
+    private readonly reflector;
+    private readonly registry;
+    private readonly logger;
+    constructor(discovery: DiscoveryService, reflector: Reflector, registry: SensorRegistry);
+    onApplicationBootstrap(): void;
+}
+
+type index$5_AxisDecoded = AxisDecoded;
+type index$5_AxisEffect = AxisEffect;
+type index$5_AxisObservation = AxisObservation;
+declare const index$5_BAND: typeof BAND;
+type index$5_HandlerDiscoveryService = HandlerDiscoveryService;
+declare const index$5_HandlerDiscoveryService: typeof HandlerDiscoveryService;
+type index$5_IntentRouter = IntentRouter;
+declare const index$5_IntentRouter: typeof IntentRouter;
+type index$5_ObservationSensor = ObservationSensor;
+type index$5_ObservationStage = ObservationStage;
+declare const index$5_PRE_DECODE_BOUNDARY: typeof PRE_DECODE_BOUNDARY;
+type index$5_SensorBand = SensorBand;
+type index$5_SensorDiscoveryService = SensorDiscoveryService;
+declare const index$5_SensorDiscoveryService: typeof SensorDiscoveryService;
+type index$5_SensorRegistry = SensorRegistry;
+declare const index$5_SensorRegistry: typeof SensorRegistry;
+declare const index$5_createObservation: typeof createObservation;
+declare const index$5_endStage: typeof endStage;
+declare const index$5_finalizeObservation: typeof finalizeObservation;
+declare const index$5_recordSensor: typeof recordSensor;
+declare const index$5_startStage: typeof startStage;
+declare namespace index$5 {
+  export { type index$5_AxisDecoded as AxisDecoded, type index$5_AxisEffect as AxisEffect, type index$5_AxisObservation as AxisObservation, index$5_BAND as BAND, index$5_HandlerDiscoveryService as HandlerDiscoveryService, index$5_IntentRouter as IntentRouter, type IntentSchema$1 as IntentSchema, type index$5_ObservationSensor as ObservationSensor, type index$5_ObservationStage as ObservationStage, index$5_PRE_DECODE_BOUNDARY as PRE_DECODE_BOUNDARY, type index$5_SensorBand as SensorBand, index$5_SensorDiscoveryService as SensorDiscoveryService, index$5_SensorRegistry as SensorRegistry, index$5_createObservation as createObservation, index$5_endStage as endStage, index$5_finalizeObservation as finalizeObservation, index$5_recordSensor as recordSensor, index$5_startStage as startStage };
+}
+
+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 index$4_Grant = Grant;
+type index$4_GrantCapability = GrantCapability;
+type index$4_GrantMeta = GrantMeta;
+type index$4_GrantStatus = GrantStatus;
+type index$4_GrantType = GrantType;
+type index$4_GrantValidationResult = GrantValidationResult;
+type index$4_LoomReceipt = LoomReceipt;
+type index$4_LoomValidationResult = LoomValidationResult;
+declare const index$4_PROOF_LOOM: typeof PROOF_LOOM;
+type index$4_PresenceChallenge = PresenceChallenge;
+type index$4_PresenceDeclaration = PresenceDeclaration;
+type index$4_PresenceProof = PresenceProof;
+type index$4_PresenceReceipt = PresenceReceipt;
+type index$4_PresenceStatus = PresenceStatus;
+type index$4_PresenceVerifyResult = PresenceVerifyResult;
+type index$4_Revocation = Revocation;
+type index$4_RevocationTargetType = RevocationTargetType;
+type index$4_ThreadState = ThreadState;
+type index$4_Writ = Writ;
+type index$4_WritBody = WritBody;
+type index$4_WritHead = WritHead;
+type index$4_WritMeta = WritMeta;
+type index$4_WritSignature = WritSignature;
+type index$4_WritValidationResult = WritValidationResult;
+declare const index$4_canonicalizeGrant: typeof canonicalizeGrant;
+declare const index$4_canonicalizeWrit: typeof canonicalizeWrit;
+declare const index$4_deriveAnchorReflection: typeof deriveAnchorReflection;
+declare namespace index$4 {
+  export { type index$4_Grant as Grant, type index$4_GrantCapability as GrantCapability, type index$4_GrantMeta as GrantMeta, type index$4_GrantStatus as GrantStatus, type index$4_GrantType as GrantType, type index$4_GrantValidationResult as GrantValidationResult, type index$4_LoomReceipt as LoomReceipt, type index$4_LoomValidationResult as LoomValidationResult, index$4_PROOF_LOOM as PROOF_LOOM, type index$4_PresenceChallenge as PresenceChallenge, type index$4_PresenceDeclaration as PresenceDeclaration, type index$4_PresenceProof as PresenceProof, type index$4_PresenceReceipt as PresenceReceipt, type index$4_PresenceStatus as PresenceStatus, type index$4_PresenceVerifyResult as PresenceVerifyResult, type index$4_Revocation as Revocation, type index$4_RevocationTargetType as RevocationTargetType, TLV_LOOM_PRESENCE_ID as TLV_PRESENCE_ID, TLV_LOOM_THREAD_HASH as TLV_THREAD_HASH, TLV_LOOM_WRIT as TLV_WRIT, type index$4_ThreadState as ThreadState, type index$4_Writ as Writ, type index$4_WritBody as WritBody, type index$4_WritHead as WritHead, type index$4_WritMeta as WritMeta, type index$4_WritSignature as WritSignature, type index$4_WritValidationResult as WritValidationResult, index$4_canonicalizeGrant as canonicalizeGrant, index$4_canonicalizeWrit as canonicalizeWrit, index$4_deriveAnchorReflection as deriveAnchorReflection };
+}
+
+declare enum BodyProfile {
+    RAW = 0,
+    TLV_MAP = 1,
+    OBJ = 2,
+    ARR = 3
+}
+interface BodyProfileValidation {
+    valid: boolean;
+    error?: string;
+    profile: BodyProfile;
+}
+declare class BodyProfileValidator {
+    private readonly logger;
+    validate(body: Uint8Array, profile: BodyProfile): BodyProfileValidation;
+    private validateRaw;
+    private validateTlvMap;
+    private validateObj;
+    private validateArr;
+}
+
+type index$3_AccessProfile = AccessProfile;
+declare const index$3_AccessProfileZ: typeof AccessProfileZ;
+type index$3_AxisContext = AxisContext;
+declare const index$3_AxisContextZ: typeof AxisContextZ;
+type index$3_AxisError = AxisError;
+declare const index$3_AxisErrorZ: typeof AxisErrorZ;
+type index$3_BodyBudgetInput = BodyBudgetInput;
+declare const index$3_BodyBudgetInputZ: typeof BodyBudgetInputZ;
+type index$3_BodyBudgetPolicy = BodyBudgetPolicy;
+declare const index$3_BodyBudgetPolicyZ: typeof BodyBudgetPolicyZ;
+type index$3_BodyProfile = BodyProfile;
+declare const index$3_BodyProfile: typeof BodyProfile;
+type index$3_BodyProfileValidation = BodyProfileValidation;
+type index$3_BodyProfileValidator = BodyProfileValidator;
+declare const index$3_BodyProfileValidator: typeof BodyProfileValidator;
+declare const index$3_BodyProfileZ: typeof BodyProfileZ;
+type index$3_Capsule = Capsule;
+type index$3_CapsuleClaims = CapsuleClaims;
+declare const index$3_CapsuleClaimsZ: typeof CapsuleClaimsZ;
+type index$3_CapsuleValidationResult = CapsuleValidationResult;
+declare const index$3_CapsuleValidationResultZ: typeof CapsuleValidationResultZ;
+type index$3_CapsuleVerifyResult = CapsuleVerifyResult;
+declare const index$3_CapsuleVerifyResultZ: typeof CapsuleVerifyResultZ;
+type index$3_CapsuleVerifySensorInput = CapsuleVerifySensorInput;
+declare const index$3_CapsuleVerifySensorInputZ: typeof CapsuleVerifySensorInputZ;
+declare const index$3_CapsuleZ: typeof CapsuleZ;
+type index$3_ChunkHashInput = ChunkHashInput;
+declare const index$3_ChunkHashInputZ: typeof ChunkHashInputZ;
+type index$3_CountryBlockDecision = CountryBlockDecision;
+declare const index$3_CountryBlockDecisionZ: typeof CountryBlockDecisionZ;
+type index$3_CountryBlockSensorInput = CountryBlockSensorInput;
+declare const index$3_CountryBlockSensorInputZ: typeof CountryBlockSensorInputZ;
+type index$3_EntropySensorInput = EntropySensorInput;
+declare const index$3_EntropySensorInputZ: typeof EntropySensorInputZ;
+declare const index$3_ExecutionMetricsZ: typeof ExecutionMetricsZ;
+type index$3_IPReputation = IPReputation;
+type index$3_IPReputationInput = IPReputationInput;
+declare const index$3_IPReputationInputZ: typeof IPReputationInputZ;
+declare const index$3_IPReputationZ: typeof IPReputationZ;
+type index$3_IntentPolicy = IntentPolicy;
+type index$3_IntentPolicyDecision = IntentPolicyDecision;
+declare const index$3_IntentPolicyDecisionZ: typeof IntentPolicyDecisionZ;
+type index$3_IntentPolicySensorInput = IntentPolicySensorInput;
+declare const index$3_IntentPolicySensorInputZ: typeof IntentPolicySensorInputZ;
+declare const index$3_IntentPolicyZ: typeof IntentPolicyZ;
+type index$3_IntentSchema = IntentSchema;
+declare const index$3_IntentSchemaZ: typeof IntentSchemaZ;
+type index$3_Passport = Passport;
+declare const index$3_PassportZ: typeof PassportZ;
+type index$3_ProofKind = ProofKind;
+declare const index$3_ProofKindZ: typeof ProofKindZ;
+type index$3_ProofPresenceInput = ProofPresenceInput;
+declare const index$3_ProofPresenceInputZ: typeof ProofPresenceInputZ;
+type index$3_ProofType = ProofType;
+declare const index$3_ProofType: typeof ProofType;
+type index$3_ProtocolStrictInput = ProtocolStrictInput;
+declare const index$3_ProtocolStrictInputZ: typeof ProtocolStrictInputZ;
+type index$3_RateLimitConfig = RateLimitConfig;
+declare const index$3_RateLimitConfigZ: typeof RateLimitConfigZ;
+type index$3_RateLimitInput = RateLimitInput;
+declare const index$3_RateLimitInputZ: typeof RateLimitInputZ;
+type index$3_RateLimitProfile = RateLimitProfile;
+declare const index$3_RateLimitProfileZ: typeof RateLimitProfileZ;
+type index$3_ScanBurstDecision = ScanBurstDecision;
+declare const index$3_ScanBurstDecisionZ: typeof ScanBurstDecisionZ;
+type index$3_ScanBurstSensorInput = ScanBurstSensorInput;
+declare const index$3_ScanBurstSensorInputZ: typeof ScanBurstSensorInputZ;
+type index$3_SchemaField = SchemaField;
+type index$3_SchemaFieldKind = SchemaFieldKind;
+declare const index$3_SchemaFieldKindZ: typeof SchemaFieldKindZ;
+declare const index$3_SchemaFieldZ: typeof SchemaFieldZ;
+type index$3_Scope = Scope;
+declare const index$3_ScopeZ: typeof ScopeZ;
+type index$3_SensitivityLevel = SensitivityLevel;
+declare const index$3_SensitivityLevelZ: typeof SensitivityLevelZ;
+type index$3_SensorChainInput = SensorChainInput;
+declare const index$3_SensorChainInputZ: typeof SensorChainInputZ;
+declare const index$3_SensorDecisionWithMetadataZ: typeof SensorDecisionWithMetadataZ;
+declare const index$3_SensorDecisionZ: typeof SensorDecisionZ;
+type index$3_SensorResult = SensorResult;
+declare const index$3_SensorResultZ: typeof SensorResultZ;
+type index$3_UploadSession = UploadSession;
+declare const index$3_UploadSessionZ: typeof UploadSessionZ;
+type index$3_UploadStatus = UploadStatus;
+declare const index$3_UploadStatusZ: typeof UploadStatusZ;
+type index$3_WsHandshakeDecision = WsHandshakeDecision;
+declare const index$3_WsHandshakeDecisionZ: typeof WsHandshakeDecisionZ;
+type index$3_WsHandshakeInput = WsHandshakeInput;
+declare const index$3_WsHandshakeInputZ: typeof WsHandshakeInputZ;
+declare namespace index$3 {
+  export { type index$3_AccessProfile as AccessProfile, index$3_AccessProfileZ as AccessProfileZ, type index$3_AxisContext as AxisContext, index$3_AxisContextZ as AxisContextZ, type index$3_AxisError as AxisError, index$3_AxisErrorZ as AxisErrorZ, type index$3_BodyBudgetInput as BodyBudgetInput, index$3_BodyBudgetInputZ as BodyBudgetInputZ, type index$3_BodyBudgetPolicy as BodyBudgetPolicy, index$3_BodyBudgetPolicyZ as BodyBudgetPolicyZ, index$3_BodyProfile as BodyProfile, type index$3_BodyProfileValidation as BodyProfileValidation, index$3_BodyProfileValidator as BodyProfileValidator, index$3_BodyProfileZ as BodyProfileZ, type index$3_Capsule as Capsule, type index$3_CapsuleClaims as CapsuleClaims, index$3_CapsuleClaimsZ as CapsuleClaimsZ, type index$3_CapsuleValidationResult as CapsuleValidationResult, index$3_CapsuleValidationResultZ as CapsuleValidationResultZ, type index$3_CapsuleVerifyResult as CapsuleVerifyResult, index$3_CapsuleVerifyResultZ as CapsuleVerifyResultZ, type index$3_CapsuleVerifySensorInput as CapsuleVerifySensorInput, index$3_CapsuleVerifySensorInputZ as CapsuleVerifySensorInputZ, index$3_CapsuleZ as CapsuleZ, type index$3_ChunkHashInput as ChunkHashInput, index$3_ChunkHashInputZ as ChunkHashInputZ, type index$3_CountryBlockDecision as CountryBlockDecision, index$3_CountryBlockDecisionZ as CountryBlockDecisionZ, type index$3_CountryBlockSensorInput as CountryBlockSensorInput, index$3_CountryBlockSensorInputZ as CountryBlockSensorInputZ, type index$3_EntropySensorInput as EntropySensorInput, index$3_EntropySensorInputZ as EntropySensorInputZ, index$3_ExecutionMetricsZ as ExecutionMetricsZ, type index$3_IPReputation as IPReputation, type index$3_IPReputationInput as IPReputationInput, index$3_IPReputationInputZ as IPReputationInputZ, index$3_IPReputationZ as IPReputationZ, type index$3_IntentPolicy as IntentPolicy, type index$3_IntentPolicyDecision as IntentPolicyDecision, index$3_IntentPolicyDecisionZ as IntentPolicyDecisionZ, type index$3_IntentPolicySensorInput as IntentPolicySensorInput, index$3_IntentPolicySensorInputZ as IntentPolicySensorInputZ, index$3_IntentPolicyZ as IntentPolicyZ, type index$3_IntentSchema as IntentSchema, index$3_IntentSchemaZ as IntentSchemaZ, type index$3_Passport as Passport, index$3_PassportZ as PassportZ, type index$3_ProofKind as ProofKind, index$3_ProofKindZ as ProofKindZ, type index$3_ProofPresenceInput as ProofPresenceInput, index$3_ProofPresenceInputZ as ProofPresenceInputZ, index$3_ProofType as ProofType, type index$3_ProtocolStrictInput as ProtocolStrictInput, index$3_ProtocolStrictInputZ as ProtocolStrictInputZ, type index$3_RateLimitConfig as RateLimitConfig, index$3_RateLimitConfigZ as RateLimitConfigZ, type index$3_RateLimitInput as RateLimitInput, index$3_RateLimitInputZ as RateLimitInputZ, type index$3_RateLimitProfile as RateLimitProfile, index$3_RateLimitProfileZ as RateLimitProfileZ, type index$3_ScanBurstDecision as ScanBurstDecision, index$3_ScanBurstDecisionZ as ScanBurstDecisionZ, type index$3_ScanBurstSensorInput as ScanBurstSensorInput, index$3_ScanBurstSensorInputZ as ScanBurstSensorInputZ, type index$3_SchemaField as SchemaField, type index$3_SchemaFieldKind as SchemaFieldKind, index$3_SchemaFieldKindZ as SchemaFieldKindZ, index$3_SchemaFieldZ as SchemaFieldZ, type index$3_Scope as Scope, index$3_ScopeZ as ScopeZ, type index$3_SensitivityLevel as SensitivityLevel, index$3_SensitivityLevelZ as SensitivityLevelZ, type index$3_SensorChainInput as SensorChainInput, index$3_SensorChainInputZ as SensorChainInputZ, index$3_SensorDecisionWithMetadataZ as SensorDecisionWithMetadataZ, index$3_SensorDecisionZ as SensorDecisionZ, type index$3_SensorResult as SensorResult, index$3_SensorResultZ as SensorResultZ, type index$3_UploadSession as UploadSession, index$3_UploadSessionZ as UploadSessionZ, type index$3_UploadStatus as UploadStatus, index$3_UploadStatusZ as UploadStatusZ, type index$3_WsHandshakeDecision as WsHandshakeDecision, index$3_WsHandshakeDecisionZ as WsHandshakeDecisionZ, type index$3_WsHandshakeInput as WsHandshakeInput, index$3_WsHandshakeInputZ as WsHandshakeInputZ };
+}
+
+declare const index$2_CAPABILITIES: typeof CAPABILITIES;
+type index$2_Capability = Capability;
+declare const index$2_INTENT_REQUIREMENTS: typeof INTENT_REQUIREMENTS;
+declare const index$2_PROOF_CAPABILITIES: typeof PROOF_CAPABILITIES;
+declare const index$2_canAccessResource: typeof canAccessResource;
+declare const index$2_hasScope: typeof hasScope;
+declare const index$2_parseScope: typeof parseScope;
+declare namespace index$2 {
+  export { index$2_CAPABILITIES as CAPABILITIES, type index$2_Capability as Capability, index$2_INTENT_REQUIREMENTS as INTENT_REQUIREMENTS, index$2_PROOF_CAPABILITIES as PROOF_CAPABILITIES, index$2_canAccessResource as canAccessResource, index$2_hasScope as hasScope, index$2_parseScope as parseScope };
+}
+
+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 {
+    private readonly config;
+    readonly name = "FrameBudgetSensor";
+    readonly order: number;
+    constructor(config: ConfigService);
+    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 ProofPresenceSensor implements AxisSensor {
+    readonly name = "ProofPresenceSensor";
+    readonly order: number;
+    supports(input: ProofPresenceInput): boolean;
+    run(input: ProofPresenceInput): Promise<SensorDecision>;
+}
+
+declare class ProtocolStrictSensor implements AxisSensor, OnModuleInit {
+    private readonly config;
+    private readonly logger;
+    readonly name = "ProtocolStrictSensor";
+    readonly order: number;
+    private protocolMagic;
+    private protocolVersion;
+    constructor(config: ConfigService);
+    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>;
+}
+
+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>;
+}
+
+declare class TLVParseSensor implements AxisSensor {
+    readonly name = "TLVParseSensor";
+    readonly order: number;
+    supports(input: SensorInput): boolean;
+    run(input: SensorInput): Promise<SensorDecision>;
+    private validateCanonicalTLV;
+}
+
+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>;
+}
+
+type index$1_AccessProfileResolverSensor = AccessProfileResolverSensor;
+declare const index$1_AccessProfileResolverSensor: typeof AccessProfileResolverSensor;
+type index$1_BodyBudgetSensor = BodyBudgetSensor;
+declare const index$1_BodyBudgetSensor: typeof BodyBudgetSensor;
+type index$1_CapabilityEnforcementSensor = CapabilityEnforcementSensor;
+declare const index$1_CapabilityEnforcementSensor: typeof CapabilityEnforcementSensor;
+type index$1_ChunkHashSensor = ChunkHashSensor;
+declare const index$1_ChunkHashSensor: typeof ChunkHashSensor;
+type index$1_EntropySensor = EntropySensor;
+declare const index$1_EntropySensor: typeof EntropySensor;
+type index$1_ExecutionTimeoutSensor = ExecutionTimeoutSensor;
+declare const index$1_ExecutionTimeoutSensor: typeof ExecutionTimeoutSensor;
+type index$1_FrameBudgetSensor = FrameBudgetSensor;
+declare const index$1_FrameBudgetSensor: typeof FrameBudgetSensor;
+type index$1_FrameHeaderSanitySensor = FrameHeaderSanitySensor;
+declare const index$1_FrameHeaderSanitySensor: typeof FrameHeaderSanitySensor;
+type index$1_HeaderTLVLimitSensor = HeaderTLVLimitSensor;
+declare const index$1_HeaderTLVLimitSensor: typeof HeaderTLVLimitSensor;
+type index$1_IntentAllowlistSensor = IntentAllowlistSensor;
+declare const index$1_IntentAllowlistSensor: typeof IntentAllowlistSensor;
+type index$1_IntentRegistrySensor = IntentRegistrySensor;
+declare const index$1_IntentRegistrySensor: typeof IntentRegistrySensor;
+type index$1_ProofPresenceSensor = ProofPresenceSensor;
+declare const index$1_ProofPresenceSensor: typeof ProofPresenceSensor;
+type index$1_ProtocolStrictSensor = ProtocolStrictSensor;
+declare const index$1_ProtocolStrictSensor: typeof ProtocolStrictSensor;
+type index$1_ReceiptPolicySensor = ReceiptPolicySensor;
+declare const index$1_ReceiptPolicySensor: typeof ReceiptPolicySensor;
+type index$1_SchemaValidationSensor = SchemaValidationSensor;
+declare const index$1_SchemaValidationSensor: typeof SchemaValidationSensor;
+type index$1_StreamScopeSensor = StreamScopeSensor;
+declare const index$1_StreamScopeSensor: typeof StreamScopeSensor;
+type index$1_TLVParseSensor = TLVParseSensor;
+declare const index$1_TLVParseSensor: typeof TLVParseSensor;
+type index$1_VarintHardeningSensor = VarintHardeningSensor;
+declare const index$1_VarintHardeningSensor: typeof VarintHardeningSensor;
+declare namespace index$1 {
+  export { index$1_AccessProfileResolverSensor as AccessProfileResolverSensor, index$1_BodyBudgetSensor as BodyBudgetSensor, index$1_CapabilityEnforcementSensor as CapabilityEnforcementSensor, index$1_ChunkHashSensor as ChunkHashSensor, index$1_EntropySensor as EntropySensor, index$1_ExecutionTimeoutSensor as ExecutionTimeoutSensor, index$1_FrameBudgetSensor as FrameBudgetSensor, index$1_FrameHeaderSanitySensor as FrameHeaderSanitySensor, index$1_HeaderTLVLimitSensor as HeaderTLVLimitSensor, index$1_IntentAllowlistSensor as IntentAllowlistSensor, index$1_IntentRegistrySensor as IntentRegistrySensor, index$1_ProofPresenceSensor as ProofPresenceSensor, index$1_ProtocolStrictSensor as ProtocolStrictSensor, index$1_ReceiptPolicySensor as ReceiptPolicySensor, index$1_SchemaValidationSensor as SchemaValidationSensor, index$1_StreamScopeSensor as StreamScopeSensor, index$1_TLVParseSensor as TLVParseSensor, index$1_VarintHardeningSensor as VarintHardeningSensor };
+}
+
+type AxisTlvDtoCtor<T = object> = new (...args: never[]) => T;
+declare function encodeAxisTlvDto<T extends object>(dtoClass: AxisTlvDtoCtor<T>, data: Partial<Record<keyof T, unknown>>): Uint8Array;
+
+declare const index_encodeAxisTlvDto: typeof encodeAxisTlvDto;
+declare namespace index {
+  export { index_encodeAxisTlvDto as encodeAxisTlvDto };
+}
+
+export { ATS1_HDR, ATS1_SCHEMA, AXIS_OPCODES, AXIS_UPLOAD_FILE_STORE, AXIS_UPLOAD_RECEIPT_SIGNER, AXIS_UPLOAD_SESSION_STORE, ats1 as Ats1Codec, type Axis1DecodedFrame, type Axis1FrameToEncode, type AxisAlg$1 as AxisAlg, type AxisPacket as AxisBinaryPacket, type AxisCapsule, type AxisCapsuleConstraints, type AxisCapsulePayload, type AxisCrudHandler, type AxisEffect, AxisFilesDownloadHandler, AxisFilesFinalizeHandler, AxisFrame$2 as AxisFrame, type AxisHandler, type AxisHandlerInit, AxisIdDto, type AxisAlg as AxisJsonAlg, type AxisFrame$1 as AxisJsonFrame, type AxisResponse as AxisJsonResponse, type AxisSig as AxisJsonSig, type AxisObservedContext, type AxisPacket$1 as AxisPacket, T as AxisPacketTags, AxisPartialType, type AxisPostSensor, type AxisPreSensor, type AxisRequestContext, AxisResponseDto, type AxisSensor, type AxisSensorInit, type AxisSig$1 as AxisSig, AxisTlvDto, CAPABILITIES, type Capability, type CapsuleMode, ContractViolationError, DEFAULT_CONTRACTS, DEFAULT_TIMEOUT, Decision, DiskUploadFileStore, type DtoSchema, type ExecutionContract, ExecutionMeter, type ExecutionMetrics, FALLBACK_CONTRACT, HANDLER_METADATA_KEY, Handler, INTENT_BODY_KEY, INTENT_METADATA_KEY, INTENT_REQUIREMENTS, INTENT_ROUTES_KEY, INTENT_SENSITIVITY_MAP, INTENT_SENSORS_KEY, INTENT_TIMEOUTS, Intent, IntentBody, type IntentDefinition, type IntentKind, type IntentOptions, type IntentRoute, IntentRouter, IntentSensitivity, IntentSensors, type IntentTlvField, type KeyStatus, PROOF_CAPABILITIES, RESPONSE_TAG_CREATED_AT, RESPONSE_TAG_CREATED_BY, RESPONSE_TAG_ID, RESPONSE_TAG_UPDATED_AT, RESPONSE_TAG_UPDATED_BY, type ReceiptEffect, RiskDecision, type RiskEvaluation, type RiskSignal, Schema2002_PasskeyLoginOptionsRes, Schema2011_PasskeyLoginVerifyReq, Schema2012_PasskeyLoginVerifyRes, Schema2021_PasskeyRegisterOptionsReq, type SensorDecision, SensorDecisions, type SensorInput, type SensorMinifiedDecision, type SensorPhaseMetadata, TLV_FIELDS_KEY, TLV_VALIDATORS_KEY, TlvEnum, TlvField, type TlvFieldKind, type TlvFieldMeta, type TlvFieldOptions, TlvMinLen, TlvRange, TlvUtf8Pattern, TlvValidate, type TlvValidatorFn, type TlvValidatorMeta, type UploadFileStat, type UploadFileStore, type UploadReceiptSigner, type UploadSessionRecord, type UploadSessionStatus, type UploadSessionStore, axis1SigningBytes, b64urlDecode, b64urlDecodeString, b64urlEncode, b64urlEncodeString, buildAts1Hdr, buildDtoDecoder, buildPacket, buildReceiptHash, buildTLVs, bytes, canAccessResource, canonicalJson, canonicalJsonExcluding, classifyIntent, index$7 as crypto, decodeAxis1Frame, index$6 as decorators, encVarint, encodeAxis1Frame, index$5 as engine, extractDtoSchema, hasScope, isAdminOpcode, isKnownOpcode, isTimestampValid, index$4 as loom, nonce16, normalizeSensorDecision, packPasskeyLoginOptionsReq, packPasskeyLoginOptionsRes, packPasskeyLoginVerifyReq, packPasskeyLoginVerifyRes, packPasskeyRegisterOptionsReq, parseScope, resolveTimeout, index$3 as schemas, index$2 as security, sensitivityName, index$1 as sensors, tlv, u64be, unpackPasskeyLoginOptionsReq, unpackPasskeyLoginVerifyReq, unpackPasskeyRegisterOptionsReq, utf8, index as utils, validateFrameShape, varintU };