@siduri-x/api 1.0.2 → 1.0.5

package/dist/auth.d.ts

@@ -0,0 +1,34 @@
+import { Request, Response, NextFunction } from 'express';
+export type Role = 'OWNER' | 'OPERATOR' | 'VIEWER' | 'user' | string;
+export interface Identity {
+    authenticated: boolean;
+    source: 'local' | 'external';
+    actorId?: string;
+    role?: Role;
+    [key: string]: unknown;
+}
+/**
+ * Checks whether an incoming request originates from the local machine loopback interface.
+ */
+export declare function isLocalRequest(req: Request): boolean;
+/**
+ * Resolves request identity according to the single-owner external machine boundary security model.
+ *
+ * - Security is enforced at the external machine boundary, NOT internally.
+ * - External network requests require a matching token (AUTH_TOKEN / OWNER_TOKEN).
+ * - There are no internal viewer/operator/owner role privileges inside the machine.
+ */
+export declare function resolveIdentity(req: Request): Identity;
+/**
+ * External boundary authentication middleware.
+ * Verifies that requests crossing the external boundary are authorized.
+ */
+export declare function requireAuth(req: Request, res: Response, next: NextFunction): Response<any, Record<string, any>> | undefined;
+/**
+ * Attaches the resolved machine identity to the request.
+ */
+export declare function attachIdentity(req: Request, res: Response, next: NextFunction): void;
+/**
+ * Compatibility alias: in single-owner model, all authenticated callers have full access.
+ */
+export declare function requireRole(allowedRoles?: Role[]): (req: Request, res: Response, next: NextFunction) => Response<any, Record<string, any>> | undefined;

package/dist/auth.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isLocalRequest = isLocalRequest;
+exports.resolveIdentity = resolveIdentity;
+exports.requireAuth = requireAuth;
+exports.attachIdentity = attachIdentity;
+exports.requireRole = requireRole;
+/**
+ * Checks whether an incoming request originates from the local machine loopback interface.
+ */
+function isLocalRequest(req) {
+    const ip = req.ip || req.socket?.remoteAddress || '';
+    return (ip === '127.0.0.1' ||
+        ip === '::1' ||
+        ip === '::ffff:127.0.0.1' ||
+        ip.endsWith('127.0.0.1') ||
+        ip === 'localhost');
+}
+/**
+ * Resolves request identity according to the single-owner external machine boundary security model.
+ *
+ * - Security is enforced at the external machine boundary, NOT internally.
+ * - External network requests require a matching token (AUTH_TOKEN / OWNER_TOKEN).
+ * - There are no internal viewer/operator/owner role privileges inside the machine.
+ */
+function resolveIdentity(req) {
+    const authHeader = req.headers?.authorization;
+    const token = authHeader?.startsWith('Bearer ') ? authHeader.split(' ')[1] : undefined;
+    const ownerToken = process.env.AUTH_TOKEN || process.env.API_TOKEN || process.env.OWNER_TOKEN;
+    const operatorToken = process.env.OPERATOR_TOKEN;
+    const configuredToken = ownerToken || operatorToken;
+    const local = isLocalRequest(req);
+    // 1. Explicit token matches
+    if (ownerToken && token === ownerToken) {
+        return { authenticated: true, source: local ? 'local' : 'external', role: 'OWNER' };
+    }
+    if (operatorToken && token === operatorToken) {
+        return { authenticated: true, source: local ? 'local' : 'external', role: 'OPERATOR' };
+    }
+    // 2. Dev local auth role fallback
+    const isDev = process.env.NODE_ENV !== 'production';
+    if (isDev && process.env.DEV_LOCAL_AUTH_ROLE) {
+        const fallbackRole = process.env.DEV_LOCAL_AUTH_ROLE.toUpperCase();
+        return {
+            authenticated: fallbackRole === 'OWNER' || fallbackRole === 'OPERATOR',
+            source: 'local',
+            role: fallbackRole,
+        };
+    }
+    // 3. Default unauthenticated / visitor
+    return { authenticated: false, source: local ? 'local' : 'external', role: 'VIEWER' };
+}
+/**
+ * External boundary authentication middleware.
+ * Verifies that requests crossing the external boundary are authorized.
+ */
+function requireAuth(req, res, next) {
+    const identity = resolveIdentity(req);
+    req.identity = identity;
+    if (!identity.authenticated) {
+        return res.status(401).json({ error: 'Unauthorized: missing or invalid authentication token' });
+    }
+    next();
+}
+/**
+ * Attaches the resolved machine identity to the request.
+ */
+function attachIdentity(req, res, next) {
+    req.identity = resolveIdentity(req);
+    next();
+}
+/**
+ * Compatibility alias: in single-owner model, all authenticated callers have full access.
+ */
+function requireRole(allowedRoles) {
+    return (req, res, next) => {
+        const identity = resolveIdentity(req);
+        req.identity = identity;
+        if (!identity.authenticated) {
+            return res.status(403).json({ error: `Forbidden: requires one of ${(allowedRoles || []).join(', ')}` });
+        }
+        next();
+    };
+}

package/dist/auth.test.d.ts

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

package/dist/auth.test.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const auth_1 = require("./auth");
+describe('Auth Identity Resolution (Single-Owner External Boundary)', () => {
+    const originalEnv = process.env;
+    beforeEach(() => {
+        jest.resetModules();
+        process.env = { ...originalEnv };
+    });
+    afterAll(() => {
+        process.env = originalEnv;
+    });
+    const mockReq = (token, ip = '192.168.1.50') => ({
+        headers: {
+            authorization: token ? `Bearer ${token}` : undefined,
+        },
+        ip,
+        socket: { remoteAddress: ip },
+    });
+    test('authenticates external request when token matches configured AUTH_TOKEN', () => {
+        process.env.AUTH_TOKEN = 'secret-auth-key';
+        process.env.NODE_ENV = 'production';
+        const identity = (0, auth_1.resolveIdentity)(mockReq('secret-auth-key'));
+        expect(identity.authenticated).toBe(true);
+        expect(identity.source).toBe('external');
+    });
+    test('authenticates external request when token matches legacy OWNER_TOKEN', () => {
+        process.env.OWNER_TOKEN = 'owner-secret';
+        process.env.NODE_ENV = 'production';
+        const identity = (0, auth_1.resolveIdentity)(mockReq('owner-secret'));
+        expect(identity.authenticated).toBe(true);
+        expect(identity.source).toBe('external');
+    });
+    test('rejects external request when token is missing in production with configured token', () => {
+        process.env.AUTH_TOKEN = 'secret-auth-key';
+        process.env.NODE_ENV = 'production';
+        const identity = (0, auth_1.resolveIdentity)(mockReq());
+        expect(identity.authenticated).toBe(false);
+    });
+    test('rejects external request for invalid token in production', () => {
+        process.env.AUTH_TOKEN = 'secret-auth-key';
+        process.env.NODE_ENV = 'production';
+        const identity = (0, auth_1.resolveIdentity)(mockReq('invalid-token'));
+        expect(identity.authenticated).toBe(false);
+    });
+    test('authenticates local loopback request in development mode', () => {
+        process.env.NODE_ENV = 'development';
+        process.env.DEV_LOCAL_AUTH_ROLE = 'OWNER';
+        process.env.AUTH_TOKEN = 'secret-key';
+        const devIdentity = (0, auth_1.resolveIdentity)(mockReq(undefined, '127.0.0.1'));
+        expect(devIdentity.authenticated).toBe(true);
+        expect(devIdentity.source).toBe('local');
+    });
+    test('requireAuth middleware accepts authenticated request and rejects unauthenticated with 401', () => {
+        process.env.AUTH_TOKEN = 'secret-key';
+        process.env.NODE_ENV = 'production';
+        const nextFn = jest.fn();
+        const resUnauthorized = {
+            status: jest.fn().mockReturnThis(),
+            json: jest.fn().mockReturnThis(),
+        };
+        // Unauthorized call
+        (0, auth_1.requireAuth)(mockReq('wrong-token'), resUnauthorized, nextFn);
+        expect(resUnauthorized.status).toHaveBeenCalledWith(401);
+        expect(nextFn).not.toHaveBeenCalled();
+        // Authorized call
+        const resAuthorized = {
+            status: jest.fn().mockReturnThis(),
+            json: jest.fn().mockReturnThis(),
+        };
+        (0, auth_1.requireAuth)(mockReq('secret-key'), resAuthorized, nextFn);
+        expect(nextFn).toHaveBeenCalled();
+    });
+});

package/dist/b0-b6.test.d.ts

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

package/dist/b0-b6.test.js

@@ -0,0 +1,121 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const supertest_1 = __importDefault(require("supertest"));
+const app_1 = require("./app");
+const runtime_1 = require("./runtime");
+describe('T0 B0 & B6 Runtime Proof Suite', () => {
+    let mockBrain;
+    let mockMemory;
+    let mockKnowledge;
+    let mockBehavior;
+    let runtime;
+    let app;
+    beforeEach(async () => {
+        mockBrain = {
+            generatePlan: jest.fn().mockImplementation(async (ctx) => {
+                return {
+                    speech: 'Hello. I am a neutral companion.',
+                    language: 'en',
+                };
+            }),
+        };
+        mockMemory = {
+            initialize: jest.fn().mockResolvedValue(undefined),
+            searchClaims: jest.fn().mockResolvedValue([]),
+            getClaims: jest.fn().mockResolvedValue([]),
+            getDirectives: jest.fn().mockResolvedValue([]),
+            getPendingClaims: jest.fn().mockResolvedValue([]),
+            proposeClaim: jest.fn().mockResolvedValue({}),
+            approveClaim: jest.fn().mockResolvedValue(undefined),
+            rejectClaim: jest.fn().mockResolvedValue(undefined),
+        };
+        mockKnowledge = {
+            search: jest.fn().mockResolvedValue([]),
+        };
+        mockBehavior = {
+            compile: jest.fn().mockResolvedValue(''),
+        };
+        const config = {
+            name: 'NeutralCompanion',
+            brain: { provider: 'openrouter' },
+            memory: { provider: 'postgres' },
+            knowledge: { provider: 'e-knowledge' },
+            behavior: { provider: 'active-self' },
+            voice: { provider: 'none' },
+            vision: { provider: 'none' },
+            body: { provider: 'none' },
+        };
+        runtime = new runtime_1.SiduriRuntime('companion-a', config, {
+            brain: mockBrain,
+            memory: mockMemory,
+            knowledge: mockKnowledge,
+            behavior: mockBehavior,
+        });
+        await runtime.initialize();
+        const runtimes = new Map([['companion-a', runtime]]);
+        const created = (0, app_1.createApp)(runtimes);
+        app = created.app;
+    });
+    // B0: Fresh companion is empty (no prior claims, no user relationship, no knowledge search on greeting)
+    describe('B0 — Fresh companion is empty', () => {
+        test('initial state has empty memory and empty directives', async () => {
+            const claims = await runtime.memory?.getClaims();
+            const directives = await runtime.memory?.getDirectives();
+            expect(claims).toEqual([]);
+            expect(directives).toEqual([]);
+        });
+        test('greeting does not query knowledge or inject prior personal knowledge', async () => {
+            const res = await (0, supertest_1.default)(app)
+                .post('/chat')
+                .send({
+                companionId: 'companion-a',
+                message: 'Hello.',
+                history: [],
+            });
+            expect(res.status).toBe(200);
+            expect(mockKnowledge.search).not.toHaveBeenCalled();
+            expect(mockBrain.generatePlan).toHaveBeenCalledWith(expect.objectContaining({
+                contextPrompt: '',
+                recipient: 'OWNER',
+            }));
+        });
+    });
+    // B6: Identity and relationship are learned, not inferred (self identity questions do not query external knowledge)
+    describe('B6 — Identity and relationship are learned, not inferred', () => {
+        test('asking "Who are you?" suppresses knowledge query and asserts self identity without external search', async () => {
+            mockBrain.generatePlan.mockResolvedValueOnce({
+                speech: 'I am NeutralCompanion.',
+                language: 'en',
+            });
+            const res = await (0, supertest_1.default)(app)
+                .post('/chat')
+                .send({
+                companionId: 'companion-a',
+                message: 'Who are you?',
+                history: [],
+            });
+            expect(res.status).toBe(200);
+            // B6 oracle: self identity chat does not query external knowledge
+            expect(mockKnowledge.search).not.toHaveBeenCalled();
+            expect(mockMemory.searchClaims).toHaveBeenCalled();
+            expect(mockBrain.generatePlan).toHaveBeenCalledWith(expect.objectContaining({
+                contextPrompt: '',
+            }));
+            expect(res.body.response.subtitle_en).toBe('I am NeutralCompanion.');
+        });
+        test('asking "Tell me about yourself" suppresses knowledge query', async () => {
+            const res = await (0, supertest_1.default)(app)
+                .post('/chat')
+                .send({
+                companionId: 'companion-a',
+                message: 'Tell me about yourself',
+                history: [],
+            });
+            expect(res.status).toBe(200);
+            expect(mockKnowledge.search).not.toHaveBeenCalled();
+        });
+    });
+});

package/dist/context-mapper.d.ts

@@ -0,0 +1,18 @@
+import { RequestContext, DiagnosticCode, ContextError } from '@siduri-x/core';
+export interface ContextMapperOptions {
+    endpointPolicy?: 'public' | 'private' | 'operator' | 'direct' | string;
+    allowAnonymousPublicChat?: boolean;
+}
+export interface MapRequestContextResult {
+    accepted: boolean;
+    context?: RequestContext;
+    diagnostics?: DiagnosticCode[];
+    error?: ContextError;
+}
+/**
+ * Maps incoming HTTP requests to a canonical RequestContext.
+ * In a single-owner, single-machine model:
+ * - Security is enforced at the external boundary, not internally between roles.
+ * - No internal audience or viewer/operator/owner role hierarchies.
+ */
+export declare function mapRequestContext(input: any, options?: ContextMapperOptions): MapRequestContextResult;

package/dist/context-mapper.js

@@ -0,0 +1,160 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mapRequestContext = mapRequestContext;
+const core_1 = require("@siduri-x/core");
+/**
+ * Maps incoming HTTP requests to a canonical RequestContext.
+ * In a single-owner, single-machine model:
+ * - Security is enforced at the external boundary, not internally between roles.
+ * - No internal audience or viewer/operator/owner role hierarchies.
+ */
+function mapRequestContext(input, options = {}) {
+    const diagnostics = [];
+    if (!input || typeof input !== 'object') {
+        return {
+            accepted: false,
+            error: {
+                code: 'MISSING_CONTEXT',
+                fields: ['request'],
+            },
+        };
+    }
+    // 1. If incoming input already has a context structure
+    if (input.context && typeof input.context === 'object') {
+        const rawCtx = input.context;
+        const companionId = input.companionId || rawCtx.companionId || input.id;
+        const correlationId = rawCtx.conversation?.correlationId || input.correlationId;
+        if (!companionId) {
+            return {
+                accepted: false,
+                error: {
+                    code: 'MISSING_CONTEXT',
+                    fields: ['companionId'],
+                    correlationId,
+                },
+            };
+        }
+        const actor = rawCtx.actor;
+        if (!actor || typeof actor !== 'object') {
+            return {
+                accepted: false,
+                error: {
+                    code: 'MISSING_CONTEXT',
+                    fields: ['actor'],
+                    correlationId,
+                },
+            };
+        }
+        // Reject invalid primary_user subject
+        if (rawCtx.subject && (rawCtx.subject.subjectId === 'primary_user' || rawCtx.subject === 'primary_user')) {
+            return {
+                accepted: false,
+                error: {
+                    code: 'FORBIDDEN_CONTEXT',
+                    message: 'Global primary_user subject is forbidden',
+                    field: 'subject.subjectId',
+                    correlationId,
+                },
+            };
+        }
+        const constructed = {
+            companionId,
+            actor: {
+                actorId: actor.actorId,
+                sessionId: actor.sessionId,
+                capabilities: Array.isArray(actor.capabilities) ? actor.capabilities : ['chat'],
+                authenticated: actor.authenticated !== undefined ? Boolean(actor.authenticated) : true,
+                authorizationRole: actor.authorizationRole,
+                ...actor,
+            },
+            conversation: {
+                correlationId,
+                channel: rawCtx.conversation?.channel || input.channel || 'direct',
+                isLive: rawCtx.conversation?.isLive,
+                ...rawCtx.conversation,
+            },
+            source: input.source || rawCtx.source || 'local',
+            subject: rawCtx.subject,
+        };
+        const validated = (0, core_1.validateRequestContext)(constructed);
+        if (!validated.accepted) {
+            return validated;
+        }
+        return {
+            accepted: true,
+            context: validated.context,
+            diagnostics: diagnostics.length > 0 ? diagnostics : undefined,
+        };
+    }
+    // 2. Synthesize clean RequestContext from request envelope
+    const companionId = input.companionId || input.id;
+    const correlationId = input.correlationId || input.conversation?.correlationId || (input.generateCorrelationId ? `corr-${Date.now()}` : undefined);
+    if (!companionId) {
+        return {
+            accepted: false,
+            error: {
+                code: 'MISSING_CONTEXT',
+                fields: ['companionId'],
+                correlationId,
+            },
+        };
+    }
+    if (companionId === 'default') {
+        diagnostics.push('companion_default_mapped_for_bootstrap');
+    }
+    if (!correlationId) {
+        return {
+            accepted: false,
+            error: {
+                code: 'MISSING_CONTEXT',
+                fields: ['conversation.correlationId'],
+            },
+        };
+    }
+    if (input.subject === 'primary_user' || input.subjectId === 'primary_user') {
+        return {
+            accepted: false,
+            error: {
+                code: 'FORBIDDEN_CONTEXT',
+                message: 'Global primary_user subject is forbidden',
+                field: 'subject',
+                correlationId,
+            },
+        };
+    }
+    const actorId = input.actorId || input.actor?.actorId || 'local-user';
+    const sessionId = input.sessionId || input.actor?.sessionId || `session-${Date.now()}`;
+    if (!input.actorId && !input.actor?.actorId) {
+        diagnostics.push('anonymous_session_generated');
+    }
+    const capabilities = Array.isArray(input.capabilities)
+        ? input.capabilities
+        : Array.isArray(input.actor?.capabilities)
+            ? input.actor.capabilities
+            : ['chat', 'system'];
+    const mappedContext = {
+        companionId,
+        actor: {
+            actorId,
+            sessionId,
+            capabilities,
+            authenticated: input.authenticated !== undefined ? Boolean(input.authenticated) : true,
+            authorizationRole: input.role ? (input.role.toLowerCase() === 'viewer' ? 'viewer' : 'administrator') : undefined,
+        },
+        conversation: {
+            channel: input.channel || input.conversation?.channel || 'direct',
+            correlationId,
+        },
+        source: input.source || 'local',
+        subject: input.subject,
+    };
+    const validated = (0, core_1.validateRequestContext)(mappedContext);
+    if (!validated.accepted) {
+        return validated;
+    }
+    return {
+        accepted: true,
+        context: validated.context,
+        diagnostics: diagnostics.length > 0 ? diagnostics : undefined,
+    };
+}

package/dist/context-mapper.test.d.ts

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

package/dist/context-mapper.test.js

@@ -0,0 +1,136 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const context_mapper_1 = require("./context-mapper");
+describe('API Request Context Mapper (Single-Owner, Single-Machine)', () => {
+    test('Local chat request maps to valid RequestContext with local user defaults', () => {
+        const input = {
+            companionId: 'companion-a',
+            message: 'Hello world',
+            correlationId: 'corr-local-1',
+        };
+        const result = (0, context_mapper_1.mapRequestContext)(input);
+        expect(result.accepted).toBe(true);
+        expect(result.context?.companionId).toBe('companion-a');
+        expect(result.context?.actor.actorId).toBe('local-user');
+        expect(result.context?.actor.authenticated).toBe(true);
+        expect(result.context?.conversation.correlationId).toBe('corr-local-1');
+        expect(result.context?.source).toBe('local');
+        expect(result.context?.subject).toBeUndefined();
+    });
+    test('Accepts structured context envelope', () => {
+        const input = {
+            companionId: 'companion-a',
+            context: {
+                actor: {
+                    actorId: 'user-main',
+                    sessionId: 'session-main',
+                    authenticated: true,
+                    capabilities: ['chat', 'system'],
+                },
+                conversation: {
+                    correlationId: 'corr-structured-1',
+                },
+            },
+            message: 'Hello structured context',
+        };
+        const result = (0, context_mapper_1.mapRequestContext)(input);
+        expect(result.accepted).toBe(true);
+        expect(result.context?.actor.actorId).toBe('user-main');
+        expect(result.context?.conversation.correlationId).toBe('corr-structured-1');
+    });
+    test('Rejects global primary_user subject', () => {
+        const input = {
+            companionId: 'companion-a',
+            context: {
+                actor: {
+                    actorId: 'user-a',
+                    sessionId: 'session-a',
+                },
+                conversation: {
+                    correlationId: 'corr-primary-user',
+                },
+                subject: {
+                    subjectId: 'primary_user',
+                    kind: 'actor',
+                },
+            },
+        };
+        const result = (0, context_mapper_1.mapRequestContext)(input);
+        expect(result.accepted).toBe(false);
+        expect(result.error?.code).toBe('FORBIDDEN_CONTEXT');
+        expect(result.error?.field).toBe('subject.subjectId');
+    });
+    test('Rejects missing actor on structured context', () => {
+        const input = {
+            companionId: 'companion-a',
+            context: {
+                actor: {
+                    actorId: '',
+                    sessionId: 'session-a',
+                },
+                conversation: {
+                    correlationId: 'corr-teach-no-actor',
+                },
+            },
+        };
+        const result = (0, context_mapper_1.mapRequestContext)(input);
+        expect(result.accepted).toBe(false);
+        expect(result.error?.code).toBe('MISSING_CONTEXT');
+        expect(result.error?.fields).toContain('actor.actorId');
+    });
+    test('Two companion IDs with same actor remain isolated under context mapper', () => {
+        const actor = {
+            actorId: 'user-a',
+            sessionId: 'session-a',
+            authenticated: true,
+        };
+        const conv = {
+            correlationId: 'corr-iso-1',
+        };
+        const reqA = { companionId: 'companion-a', context: { actor, conversation: conv } };
+        const reqB = { companionId: 'companion-b', context: { actor, conversation: conv } };
+        const resA = (0, context_mapper_1.mapRequestContext)(reqA);
+        const resB = (0, context_mapper_1.mapRequestContext)(reqB);
+        expect(resA.accepted).toBe(true);
+        expect(resB.accepted).toBe(true);
+        expect(resA.context?.companionId).toBe('companion-a');
+        expect(resB.context?.companionId).toBe('companion-b');
+    });
+    test('Rejects missing companionId', () => {
+        const input = {
+            message: 'No companion id',
+            correlationId: 'corr-no-comp',
+        };
+        const result = (0, context_mapper_1.mapRequestContext)(input);
+        expect(result.accepted).toBe(false);
+        expect(result.error?.code).toBe('MISSING_CONTEXT');
+        expect(result.error?.fields).toContain('companionId');
+    });
+    test('Rejects missing correlation ID when generateCorrelationId is not set', () => {
+        const input = {
+            companionId: 'companion-a',
+            context: {
+                actor: {
+                    actorId: 'user-a',
+                    sessionId: 'session-a',
+                },
+                conversation: {
+                    correlationId: '',
+                },
+            },
+        };
+        const result = (0, context_mapper_1.mapRequestContext)(input);
+        expect(result.accepted).toBe(false);
+        expect(result.error?.code).toBe('MISSING_CONTEXT');
+        expect(result.error?.fields).toContain('conversation.correlationId');
+    });
+    test('Generates correlationId when generateCorrelationId option is true', () => {
+        const input = {
+            companionId: 'companion-a',
+            generateCorrelationId: true,
+        };
+        const result = (0, context_mapper_1.mapRequestContext)(input);
+        expect(result.accepted).toBe(true);
+        expect(result.context?.conversation.correlationId).toMatch(/^corr-/);
+    });
+});

package/dist/cors.d.ts

@@ -0,0 +1,3 @@
+import cors from 'cors';
+export declare function getAllowedOrigins(): Set<string>;
+export declare function createCorsOptions(): cors.CorsOptions;