@siduri-x/core 1.0.4 → 1.0.5

package/dist/context.js

@@ -1,92 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isValidAuthorizationRole = isValidAuthorizationRole;
-exports.isValidChannel = isValidChannel;
-exports.isValidSubjectKind = isValidSubjectKind;
-exports.validateRequestContext = validateRequestContext;
-function isValidAuthorizationRole(role) {
-    return role === 'viewer' || role === 'operator' || role === 'administrator';
-}
-function isValidChannel(channel) {
-    return channel === 'public' || channel === 'direct' || channel === 'private' || channel === 'operator';
-}
-function isValidSubjectKind(kind) {
-    return kind === 'actor' || kind === 'companion' || kind === 'configured';
-}
-function validateRequestContext(context) {
-    if (!context || typeof context !== 'object') {
-        return {
-            accepted: false,
-            error: {
-                code: 'MISSING_CONTEXT',
-                fields: ['context'],
-            },
-        };
-    }
-    const ctx = context;
-    const missingFields = [];
-    if (!ctx.companionId || typeof ctx.companionId !== 'string' || ctx.companionId.trim() === '') {
-        missingFields.push('companionId');
-    }
-    if (!ctx.actor || typeof ctx.actor !== 'object') {
-        missingFields.push('actor');
-    }
-    else {
-        if (!ctx.actor.actorId || typeof ctx.actor.actorId !== 'string' || ctx.actor.actorId.trim() === '') {
-            missingFields.push('actor.actorId');
-        }
-        if (!ctx.actor.sessionId || typeof ctx.actor.sessionId !== 'string' || ctx.actor.sessionId.trim() === '') {
-            missingFields.push('actor.sessionId');
-        }
-        if (!isValidAuthorizationRole(ctx.actor.authorizationRole)) {
-            missingFields.push('actor.authorizationRole');
-        }
-        if (!Array.isArray(ctx.actor.capabilities)) {
-            missingFields.push('actor.capabilities');
-        }
-        if (typeof ctx.actor.authenticated !== 'boolean') {
-            missingFields.push('actor.authenticated');
-        }
-    }
-    if (!ctx.conversation || typeof ctx.conversation !== 'object') {
-        missingFields.push('conversation');
-    }
-    else {
-        if (!isValidChannel(ctx.conversation.channel)) {
-            missingFields.push('conversation.channel');
-        }
-        if (!ctx.conversation.audienceId || typeof ctx.conversation.audienceId !== 'string' || ctx.conversation.audienceId.trim() === '') {
-            missingFields.push('conversation.audienceId');
-        }
-        if (!ctx.conversation.correlationId || typeof ctx.conversation.correlationId !== 'string' || ctx.conversation.correlationId.trim() === '') {
-            missingFields.push('conversation.correlationId');
-        }
-    }
-    if (ctx.subject !== undefined) {
-        if (!ctx.subject || typeof ctx.subject !== 'object') {
-            missingFields.push('subject');
-        }
-        else {
-            if (!ctx.subject.subjectId || typeof ctx.subject.subjectId !== 'string' || ctx.subject.subjectId.trim() === '') {
-                missingFields.push('subject.subjectId');
-            }
-            if (!isValidSubjectKind(ctx.subject.kind)) {
-                missingFields.push('subject.kind');
-            }
-        }
-    }
-    if (missingFields.length > 0) {
-        return {
-            accepted: false,
-            error: {
-                code: 'MISSING_CONTEXT',
-                fields: missingFields,
-                correlationId: ctx.conversation?.correlationId,
-            },
-        };
-    }
-    return {
-        accepted: true,
-        context: ctx,
-    };
-}

package/dist/context.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/context.test.js

@@ -1,109 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const context_1 = require("./context");
-describe('Core Context Contract (P1)', () => {
-    const validContext = {
-        companionId: 'companion-a',
-        actor: {
-            actorId: 'actor-a',
-            sessionId: 'session-a',
-            authorizationRole: 'viewer',
-            capabilities: ['chat:public'],
-            authenticated: false,
-        },
-        conversation: {
-            channel: 'public',
-            audienceId: 'audience-public',
-            correlationId: 'corr-a',
-        },
-        subject: {
-            subjectId: 'actor:actor-a',
-            kind: 'actor',
-            ownerActorId: 'actor-a',
-        },
-    };
-    test('validates a correct neutral RequestContext', () => {
-        const result = (0, context_1.validateRequestContext)(validContext);
-        expect(result.accepted).toBe(true);
-        expect(result.context).toEqual(validContext);
-        expect(result.error).toBeUndefined();
-    });
-    test('validates a correct RequestContext without subject', () => {
-        const { subject, ...contextWithoutSubject } = validContext;
-        const result = (0, context_1.validateRequestContext)(contextWithoutSubject);
-        expect(result.accepted).toBe(true);
-        expect(result.context?.subject).toBeUndefined();
-    });
-    test('rejects missing root context or non-object', () => {
-        const result = (0, context_1.validateRequestContext)(null);
-        expect(result.accepted).toBe(false);
-        expect(result.error?.code).toBe('MISSING_CONTEXT');
-        expect(result.error?.fields).toContain('context');
-    });
-    test('rejects missing companionId, actor, or conversation', () => {
-        const result = (0, context_1.validateRequestContext)({});
-        expect(result.accepted).toBe(false);
-        expect(result.error?.code).toBe('MISSING_CONTEXT');
-        expect(result.error?.fields).toEqual(expect.arrayContaining(['companionId', 'actor', 'conversation']));
-    });
-    test('validates authorization role constraints', () => {
-        expect((0, context_1.isValidAuthorizationRole)('viewer')).toBe(true);
-        expect((0, context_1.isValidAuthorizationRole)('operator')).toBe(true);
-        expect((0, context_1.isValidAuthorizationRole)('administrator')).toBe(true);
-        expect((0, context_1.isValidAuthorizationRole)('owner')).toBe(false);
-        expect((0, context_1.isValidAuthorizationRole)('user')).toBe(false);
-        expect((0, context_1.isValidAuthorizationRole)('MASTER')).toBe(false);
-        const invalidRoleCtx = {
-            ...validContext,
-            actor: { ...validContext.actor, authorizationRole: 'invalid_role' },
-        };
-        const result = (0, context_1.validateRequestContext)(invalidRoleCtx);
-        expect(result.accepted).toBe(false);
-        expect(result.error?.fields).toContain('actor.authorizationRole');
-    });
-    test('validates channel constraints', () => {
-        expect((0, context_1.isValidChannel)('public')).toBe(true);
-        expect((0, context_1.isValidChannel)('direct')).toBe(true);
-        expect((0, context_1.isValidChannel)('private')).toBe(true);
-        expect((0, context_1.isValidChannel)('operator')).toBe(true);
-        expect((0, context_1.isValidChannel)('chat')).toBe(false);
-        expect((0, context_1.isValidChannel)('MASTER_PRIVATE')).toBe(false);
-        const invalidChannelCtx = {
-            ...validContext,
-            conversation: { ...validContext.conversation, channel: 'invalid_channel' },
-        };
-        const result = (0, context_1.validateRequestContext)(invalidChannelCtx);
-        expect(result.accepted).toBe(false);
-        expect(result.error?.fields).toContain('conversation.channel');
-    });
-    test('validates subject kinds and constraints', () => {
-        expect((0, context_1.isValidSubjectKind)('actor')).toBe(true);
-        expect((0, context_1.isValidSubjectKind)('companion')).toBe(true);
-        expect((0, context_1.isValidSubjectKind)('configured')).toBe(true);
-        expect((0, context_1.isValidSubjectKind)('user')).toBe(false);
-        const invalidSubjectCtx = {
-            ...validContext,
-            subject: { subjectId: 'subject-1', kind: 'invalid_kind' },
-        };
-        const result = (0, context_1.validateRequestContext)(invalidSubjectCtx);
-        expect(result.accepted).toBe(false);
-        expect(result.error?.fields).toContain('subject.kind');
-    });
-    test('rejects missing correlationId and preserves correlationId in error if present', () => {
-        const missingCorr = {
-            ...validContext,
-            conversation: { ...validContext.conversation, correlationId: '' },
-        };
-        const result = (0, context_1.validateRequestContext)(missingCorr);
-        expect(result.accepted).toBe(false);
-        expect(result.error?.fields).toContain('conversation.correlationId');
-        const missingActorId = {
-            ...validContext,
-            actor: { ...validContext.actor, actorId: '' },
-        };
-        const result2 = (0, context_1.validateRequestContext)(missingActorId);
-        expect(result2.accepted).toBe(false);
-        expect(result2.error?.fields).toContain('actor.actorId');
-        expect(result2.error?.correlationId).toBe('corr-a');
-    });
-});

package/dist/dispatcher.d.ts

@@ -1,14 +0,0 @@
-import { ExperienceAdapter, ExperienceEvent, ExperienceAdapterResult } from './experience';
-export interface DispatchSummary {
-    dispatched: boolean;
-    eventResults: {
-        event: ExperienceEvent;
-        result: ExperienceAdapterResult;
-    }[];
-}
-export declare class ExperienceDispatcher {
-    private readonly adapters;
-    private readonly dispatchedEventIds;
-    registerAdapter(adapter: ExperienceAdapter): void;
-    dispatchEvents(events: ExperienceEvent[]): Promise<DispatchSummary>;
-}

package/dist/dispatcher.js

@@ -1,40 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ExperienceDispatcher = void 0;
-class ExperienceDispatcher {
-    adapters = [];
-    dispatchedEventIds = new Set();
-    registerAdapter(adapter) {
-        this.adapters.push(adapter);
-    }
-    async dispatchEvents(events) {
-        const eventResults = [];
-        for (const event of events) {
-            // Replay / duplicate dispatch protection: each eventId is dispatched only once
-            if (this.dispatchedEventIds.has(event.eventId)) {
-                eventResults.push({
-                    event,
-                    result: {
-                        accepted: false,
-                        eventId: event.eventId,
-                        lifecycle: 'FAILED',
-                        error: 'Duplicate event ID already dispatched',
-                        reason: 'DUPLICATE_EVENT_DISPATCH',
-                    },
-                });
-                continue;
-            }
-            this.dispatchedEventIds.add(event.eventId);
-            const matchingAdapters = this.adapters.filter((a) => a.kind === event.kind);
-            for (const adapter of matchingAdapters) {
-                const result = await adapter.handleEvent(event);
-                eventResults.push({ event, result });
-            }
-        }
-        return {
-            dispatched: eventResults.some((r) => r.result.accepted),
-            eventResults,
-        };
-    }
-}
-exports.ExperienceDispatcher = ExperienceDispatcher;

package/dist/dispatcher.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/dispatcher.test.js

@@ -1,60 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const dispatcher_1 = require("./dispatcher");
-const experience_1 = require("./experience");
-describe('T5 ExperienceDispatcher Contract Suite', () => {
-    let dispatcher;
-    let mockVoiceAdapter;
-    let mockAvatarAdapter;
-    beforeEach(() => {
-        dispatcher = new dispatcher_1.ExperienceDispatcher();
-        mockVoiceAdapter = {
-            kind: 'voice',
-            handleEvent: jest.fn().mockImplementation(async (event) => ({
-                accepted: true,
-                eventId: event.eventId,
-                lifecycle: 'STARTED',
-            })),
-        };
-        mockAvatarAdapter = {
-            kind: 'avatar',
-            handleEvent: jest.fn().mockImplementation(async (event) => ({
-                accepted: true,
-                eventId: event.eventId,
-                lifecycle: 'STARTED',
-            })),
-        };
-        dispatcher.registerAdapter(mockVoiceAdapter);
-        dispatcher.registerAdapter(mockAvatarAdapter);
-    });
-    test('dispatches experience events to matching adapters', async () => {
-        const events = (0, experience_1.createExperienceEvents)({
-            responseId: 'resp-1',
-            companionId: 'companion-a',
-            correlationId: 'corr-1',
-            channel: 'public',
-            audienceId: 'audience-public',
-            speech: 'Hello dispatch',
-            language: 'en',
-        });
-        const summary = await dispatcher.dispatchEvents(events);
-        expect(summary.dispatched).toBe(true);
-        expect(summary.eventResults.length).toBe(2);
-        expect(mockVoiceAdapter.handleEvent).toHaveBeenCalledTimes(1);
-        expect(mockAvatarAdapter.handleEvent).toHaveBeenCalledTimes(1);
-    });
-    test('does not dispatch when no matching adapters registered', async () => {
-        const emptyDispatcher = new dispatcher_1.ExperienceDispatcher();
-        const events = (0, experience_1.createExperienceEvents)({
-            responseId: 'resp-1',
-            companionId: 'companion-a',
-            correlationId: 'corr-1',
-            channel: 'public',
-            audienceId: 'audience-public',
-            speech: 'Hello empty',
-        });
-        const summary = await emptyDispatcher.dispatchEvents(events);
-        expect(summary.dispatched).toBe(false);
-        expect(summary.eventResults.length).toBe(0);
-    });
-});

package/dist/ear-types.d.ts

@@ -1,33 +0,0 @@
-import { RequestContext } from './context';
-import { EarPerception } from './index';
-export interface EarLimitsConfig {
-    maxTextLength?: number;
-    maxAudioBytes?: number;
-    allowedAudioMimeTypes?: string[];
-    maxDurationSeconds?: number;
-    transcriptionTimeoutMs?: number;
-}
-export interface EarPerceptionMetadata extends Record<string, unknown> {
-    source?: string;
-    channel?: string;
-    modality?: 'text' | 'audio' | 'object' | 'system';
-    confidence?: number;
-    provenance?: string;
-    actorId?: string;
-    sessionId?: string;
-    correlationId?: string;
-    byteSize?: number;
-    durationSeconds?: number;
-    mimeType?: string;
-}
-export interface HardenedEarPerception extends EarPerception {
-    modality: 'text' | 'audio' | 'object' | 'system';
-    metadata?: EarPerceptionMetadata;
-    rawConfidence?: number;
-}
-export interface EarIngestOptions {
-    source?: string;
-    context?: RequestContext;
-    mimeType?: string;
-    durationSeconds?: number;
-}

package/dist/ear-types.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

package/dist/evidence.d.ts

@@ -1,72 +0,0 @@
-export type EvidenceOrigin = 'knowledge' | 'observation' | 'ocr' | 'platform' | 'conversation';
-export type EvidenceTrust = 'configured' | 'provider' | 'untrusted';
-export type EvidenceSensitivity = 'public' | 'private' | 'restricted';
-export interface EvidenceRecord {
-    evidenceId: string;
-    sourceId: string;
-    documentId?: string;
-    chunkId?: string;
-    locator?: string;
-    revision?: string;
-    origin: EvidenceOrigin;
-    confidence?: number;
-    uncertainty?: string;
-    createdAt: string;
-    expiresAt?: string;
-    trust: EvidenceTrust;
-    sensitivity: EvidenceSensitivity;
-    allowedAudiences: string[];
-    companionId: string;
-    correlationId: string;
-}
-export type ResponseApprovalStatus = 'STAGED' | 'APPROVED' | 'REJECTED' | 'EXPIRED' | 'EMITTED';
-export type ResponseGateReasonCode = 'APPROVED_DIRECT' | 'APPROVAL_REQUIRED' | 'UNKNOWN_APPROVAL_ID' | 'APPROVAL_ID_MISMATCH' | 'COMPANION_MISMATCH' | 'AUDIENCE_MISMATCH' | 'EVIDENCE_EXPIRED' | 'EVIDENCE_SENSITIVITY_EXCLUDED' | 'UNRESOLVED_LOW_CONFIDENCE' | 'EMPTY_SPEECH' | 'PROPOSAL_VALIDATION_FAILED' | 'EXPLICITLY_REJECTED';
-export interface ResponseCitation {
-    sourceId: string;
-    documentId?: string;
-    chunkId?: string;
-    locator?: string;
-    revision?: string;
-}
-export interface StagedResponsePlan {
-    responseId: string;
-    companionId: string;
-    correlationId: string;
-    channel: 'public' | 'direct' | 'private' | 'operator';
-    audienceId: string;
-    speech: string;
-    language: string;
-    evidenceIds: string[];
-    citations: ResponseCitation[];
-    confidenceSummary: number;
-    uncertaintySummary?: string;
-    requiresApproval: boolean;
-    status: ResponseApprovalStatus;
-    createdAt: string;
-    expiresAt?: string;
-    memoryProposals?: any[];
-    behaviorProposals?: any[];
-    internalMonologue?: string;
-}
-export interface ResponseGateEvaluation {
-    admissible: boolean;
-    disposition: ResponseApprovalStatus;
-    reasonCode: ResponseGateReasonCode;
-    stagedPlan: StagedResponsePlan;
-    filteredEvidenceIds: string[];
-    filteredCitations: ResponseCitation[];
-    diagnostics?: Record<string, string>;
-}
-export interface EvidenceFilterOptions {
-    companionId: string;
-    channel: 'public' | 'direct' | 'private' | 'operator';
-    audienceId: string;
-    now?: string | Date;
-}
-export declare function filterEvidenceRecords(records: EvidenceRecord[], options: EvidenceFilterOptions): {
-    admitted: EvidenceRecord[];
-    excluded: {
-        record: EvidenceRecord;
-        reason: string;
-    }[];
-};

package/dist/evidence.js

@@ -1,45 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.filterEvidenceRecords = filterEvidenceRecords;
-function filterEvidenceRecords(records, options) {
-    const admitted = [];
-    const excluded = [];
-    const nowTime = options.now ? new Date(options.now).getTime() : Date.now();
-    for (const record of records) {
-        // 1. Companion isolation
-        if (record.companionId !== options.companionId) {
-            excluded.push({ record, reason: 'companion_isolation_mismatch' });
-            continue;
-        }
-        // 2. Expiry
-        if (record.expiresAt) {
-            const expTime = new Date(record.expiresAt).getTime();
-            if (expTime <= nowTime) {
-                excluded.push({ record, reason: 'evidence_expired' });
-                continue;
-            }
-        }
-        // 3. Audience intersection
-        if (record.allowedAudiences &&
-            record.allowedAudiences.length > 0 &&
-            !record.allowedAudiences.includes(options.audienceId)) {
-            excluded.push({ record, reason: 'audience_not_allowed' });
-            continue;
-        }
-        // 4. Sensitivity policy based on channel
-        if (options.channel === 'public') {
-            if (record.sensitivity !== 'public') {
-                excluded.push({ record, reason: 'sensitivity_private_in_public_channel' });
-                continue;
-            }
-        }
-        else if (options.channel === 'direct') {
-            if (record.sensitivity === 'restricted') {
-                excluded.push({ record, reason: 'sensitivity_restricted_in_direct_channel' });
-                continue;
-            }
-        }
-        admitted.push(record);
-    }
-    return { admitted, excluded };
-}

package/dist/evidence.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/evidence.test.js

@@ -1,101 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const evidence_1 = require("./evidence");
-describe('T4 Evidence & Disclosure Core Contract', () => {
-    const baseRecord = {
-        evidenceId: 'ev-1',
-        sourceId: 'src-1',
-        origin: 'knowledge',
-        trust: 'configured',
-        sensitivity: 'public',
-        allowedAudiences: ['audience-public'],
-        companionId: 'companion-a',
-        correlationId: 'corr-1',
-        createdAt: new Date(Date.now() - 5000).toISOString(),
-    };
-    test('companion isolation excludes foreign companion evidence', () => {
-        const records = [
-            { ...baseRecord, evidenceId: 'ev-mine', companionId: 'companion-a' },
-            { ...baseRecord, evidenceId: 'ev-foreign', companionId: 'companion-b' },
-        ];
-        const options = {
-            companionId: 'companion-a',
-            channel: 'public',
-            audienceId: 'audience-public',
-        };
-        const { admitted, excluded } = (0, evidence_1.filterEvidenceRecords)(records, options);
-        expect(admitted.map((e) => e.evidenceId)).toEqual(['ev-mine']);
-        expect(excluded).toEqual([
-            expect.objectContaining({
-                record: expect.objectContaining({ evidenceId: 'ev-foreign' }),
-                reason: 'companion_isolation_mismatch',
-            }),
-        ]);
-    });
-    test('expired evidence is excluded', () => {
-        const records = [
-            { ...baseRecord, evidenceId: 'ev-valid', expiresAt: new Date(Date.now() + 60000).toISOString() },
-            { ...baseRecord, evidenceId: 'ev-expired', expiresAt: new Date(Date.now() - 1000).toISOString() },
-        ];
-        const options = {
-            companionId: 'companion-a',
-            channel: 'public',
-            audienceId: 'audience-public',
-        };
-        const { admitted, excluded } = (0, evidence_1.filterEvidenceRecords)(records, options);
-        expect(admitted.map((e) => e.evidenceId)).toEqual(['ev-valid']);
-        expect(excluded).toEqual([
-            expect.objectContaining({
-                record: expect.objectContaining({ evidenceId: 'ev-expired' }),
-                reason: 'evidence_expired',
-            }),
-        ]);
-    });
-    test('audience intersection excludes non-matching audiences', () => {
-        const records = [
-            { ...baseRecord, evidenceId: 'ev-public', allowedAudiences: ['audience-public'] },
-            { ...baseRecord, evidenceId: 'ev-direct-only', allowedAudiences: ['audience-direct-a'] },
-        ];
-        const options = {
-            companionId: 'companion-a',
-            channel: 'public',
-            audienceId: 'audience-public',
-        };
-        const { admitted, excluded } = (0, evidence_1.filterEvidenceRecords)(records, options);
-        expect(admitted.map((e) => e.evidenceId)).toEqual(['ev-public']);
-        expect(excluded).toEqual([
-            expect.objectContaining({
-                record: expect.objectContaining({ evidenceId: 'ev-direct-only' }),
-                reason: 'audience_not_allowed',
-            }),
-        ]);
-    });
-    test('sensitivity policy excludes private and restricted evidence from public channels', () => {
-        const records = [
-            { ...baseRecord, evidenceId: 'ev-pub', sensitivity: 'public', allowedAudiences: ['audience-public'] },
-            { ...baseRecord, evidenceId: 'ev-priv', sensitivity: 'private', allowedAudiences: ['audience-public'] },
-            { ...baseRecord, evidenceId: 'ev-rest', sensitivity: 'restricted', allowedAudiences: ['audience-public'] },
-        ];
-        const { admitted, excluded } = (0, evidence_1.filterEvidenceRecords)(records, {
-            companionId: 'companion-a',
-            channel: 'public',
-            audienceId: 'audience-public',
-        });
-        expect(admitted.map((e) => e.evidenceId)).toEqual(['ev-pub']);
-        expect(excluded.map((e) => e.record.evidenceId)).toEqual(['ev-priv', 'ev-rest']);
-    });
-    test('direct channel permits private sensitivity but excludes restricted', () => {
-        const records = [
-            { ...baseRecord, evidenceId: 'ev-pub', sensitivity: 'public', allowedAudiences: ['audience-direct-a'] },
-            { ...baseRecord, evidenceId: 'ev-priv', sensitivity: 'private', allowedAudiences: ['audience-direct-a'] },
-            { ...baseRecord, evidenceId: 'ev-rest', sensitivity: 'restricted', allowedAudiences: ['audience-direct-a'] },
-        ];
-        const { admitted, excluded } = (0, evidence_1.filterEvidenceRecords)(records, {
-            companionId: 'companion-a',
-            channel: 'direct',
-            audienceId: 'audience-direct-a',
-        });
-        expect(admitted.map((e) => e.evidenceId)).toEqual(['ev-pub', 'ev-priv']);
-        expect(excluded.map((e) => e.record.evidenceId)).toEqual(['ev-rest']);
-    });
-});

package/dist/experience.d.ts

@@ -1,56 +0,0 @@
-import { Channel } from './context';
-import { ResponseCitation } from './evidence';
-export type ExperienceEventKind = 'voice' | 'caption' | 'avatar' | 'platform_action';
-export type ExperienceEventLifecycle = 'STARTED' | 'PROGRESS' | 'COMPLETED' | 'FAILED';
-export interface ExperienceEvent {
-    eventId: string;
-    companionId: string;
-    responseId: string;
-    correlationId: string;
-    channel: Channel;
-    audienceId: string;
-    approval: 'APPROVED';
-    kind: ExperienceEventKind;
-    lifecycle: ExperienceEventLifecycle;
-    evidenceIds: string[];
-    citations?: ResponseCitation[];
-    text?: string;
-    language?: string;
-    action?: string;
-    expression?: string;
-    createdAt: string;
-    expiresAt?: string;
-}
-export interface ExperienceAdapterResult {
-    accepted: boolean;
-    eventId: string;
-    lifecycle: ExperienceEventLifecycle;
-    error?: string;
-    reason?: string;
-    audioBuffer?: Uint8Array;
-    metadata?: Record<string, unknown>;
-}
-export interface ExperienceAdapter {
-    readonly kind: ExperienceEventKind;
-    handleEvent(event: ExperienceEvent): Promise<ExperienceAdapterResult>;
-}
-export interface CreateExperienceEventsOptions {
-    responseId: string;
-    companionId: string;
-    correlationId: string;
-    channel: Channel;
-    audienceId: string;
-    speech: string;
-    language?: string;
-    evidenceIds?: string[];
-    citations?: ResponseCitation[];
-    expression?: string;
-    action?: string;
-    expiresAt?: string;
-    now?: string | Date;
-}
-export declare function createExperienceEvents(options: CreateExperienceEventsOptions): ExperienceEvent[];
-export declare function validateExperienceEvent(event: unknown): {
-    valid: boolean;
-    error?: string;
-};