@frontmcp/sdk 0.7.2 → 0.8.0

package/common/types/options/skills-http/interfaces.d.ts

@@ -0,0 +1,321 @@
+/**
+ * @module skillsConfig
+ *
+ * Skills HTTP Endpoints Configuration
+ *
+ * This module enables exposing FrontMCP skills via HTTP endpoints for multi-agent
+ * architectures where:
+ * - **Planner agents** fetch skills via HTTP to create execution plans
+ * - **Sub-agents** connect to specific apps for tool execution without skills
+ * - **Backend servers** fetch skills via HTTP GET before calling LLMs
+ *
+ * ## HTTP Endpoints
+ *
+ * When `skillsConfig.enabled: true`, the following endpoints are available:
+ *
+ * | Endpoint          | Method | Description                                    |
+ * |-------------------|--------|------------------------------------------------|
+ * | `/llm.txt`        | GET    | Compact skill summaries (name, description, tools, tags) |
+ * | `/llm_full.txt`   | GET    | Full skills with complete instructions and tool schemas |
+ * | `/skills`         | GET    | JSON API - List all skills                     |
+ * | `/skills?query=X` | GET    | JSON API - Search skills with optional filters |
+ * | `/skills/{id}`    | GET    | JSON API - Get specific skill by ID/name       |
+ *
+ * ## Visibility Control
+ *
+ * Skills can have a `visibility` property to control where they appear:
+ * - `'mcp'`: Only via searchSkills/loadSkill MCP tools
+ * - `'http'`: Only via HTTP API endpoints (/llm.txt, /skills)
+ * - `'both'`: Visible in both MCP and HTTP (default)
+ *
+ * ```typescript
+ * @Skill({
+ *   name: 'internal-process',
+ *   visibility: 'http',  // Only visible via HTTP endpoints
+ *   instructions: { file: './internal.md' },
+ * })
+ * class InternalProcessSkill {}
+ * ```
+ *
+ * ## Architecture Examples
+ *
+ * ### Multi-Agent Architecture
+ * ```
+ * ┌──────────────────┐     HTTP GET /skills
+ * │  Planner Agent   │ ──────────────────────> FrontMCP Server
+ * └────────┬─────────┘                               │
+ *          │ creates plan                            │ /llm.txt
+ *          ▼                                         │ /skills
+ * ┌──────────────────┐     MCP (tools only)          ▼
+ * │  Executor Agent  │ <──────────────────── Tools (no skills listed)
+ * └──────────────────┘
+ * ```
+ *
+ * ### Backend Server Integration
+ * ```typescript
+ * // Fetch skills before calling LLM
+ * const skills = await fetch('https://api.example.com/llm.txt');
+ * const systemPrompt = `Available skills:\n${await skills.text()}`;
+ *
+ * // Call LLM with skill context
+ * const response = await llm.chat({ system: systemPrompt, user: query });
+ * ```
+ *
+ * @see {@link SkillsConfigOptions} for configuration options
+ * @see {@link SkillMetadata.visibility} for per-skill visibility control
+ */
+/**
+ * Authentication mode for skills HTTP endpoints.
+ * - 'inherit': Use the server's default authentication
+ * - 'public': No authentication required
+ * - 'api-key': Require API key in X-API-Key header or Authorization: ApiKey <key>
+ * - 'bearer': Require JWT token, validated against configured issuer
+ */
+export type SkillsConfigAuthMode = 'inherit' | 'public' | 'api-key' | 'bearer';
+/**
+ * JWT validation configuration for bearer auth mode.
+ */
+export interface SkillsConfigJwtOptions {
+    /**
+     * JWT issuer URL (e.g., 'https://auth.example.com').
+     * Required when using bearer auth mode.
+     */
+    issuer: string;
+    /**
+     * Expected audience claim (optional).
+     * If provided, the JWT must have this audience.
+     */
+    audience?: string;
+    /**
+     * JWKS URL for key discovery.
+     * Defaults to {issuer}/.well-known/jwks.json
+     */
+    jwksUrl?: string;
+}
+/**
+ * Configuration for an individual skills HTTP endpoint.
+ * Controls whether the endpoint is enabled and its path.
+ * Authentication is configured at the top level of SkillsConfigOptions.
+ */
+export interface SkillsConfigEndpointConfig {
+    /**
+     * Whether this endpoint is enabled.
+     * @default true
+     */
+    enabled?: boolean;
+    /**
+     * Custom path override for this endpoint.
+     * If not specified, uses the default path.
+     */
+    path?: string;
+}
+/**
+ * Options for exposing skills via HTTP endpoints.
+ *
+ * When enabled, skills can be discovered and loaded via HTTP endpoints
+ * in addition to (or instead of) MCP tools.
+ *
+ * Authentication is configured once at the top level and applies to all
+ * HTTP endpoints. Individual endpoints can be enabled/disabled separately.
+ *
+ * @example Basic usage (public access)
+ * ```typescript
+ * @FrontMcp({
+ *   skillsConfig: {
+ *     enabled: true,
+ *     auth: 'public',
+ *   },
+ * })
+ * ```
+ *
+ * @example Protected API with API key
+ * ```typescript
+ * @FrontMcp({
+ *   skillsConfig: {
+ *     enabled: true,
+ *     auth: 'api-key',
+ *     apiKeys: ['sk-xxx', 'sk-yyy'],
+ *   },
+ * })
+ * ```
+ *
+ * @example Custom paths with prefix
+ * ```typescript
+ * @FrontMcp({
+ *   skillsConfig: {
+ *     enabled: true,
+ *     prefix: '/api/v1',
+ *     auth: 'public',
+ *     llmTxt: { path: '/api/v1/llm.txt' },
+ *     api: { enabled: false },  // Disable JSON API
+ *   },
+ * })
+ * ```
+ *
+ * @example HTTP only (no MCP tools)
+ * ```typescript
+ * @FrontMcp({
+ *   skillsConfig: {
+ *     enabled: true,
+ *     auth: 'public',
+ *     mcpTools: false,  // No searchSkills/loadSkill MCP tools
+ *   },
+ * })
+ * ```
+ */
+export interface SkillsConfigOptions {
+    /**
+     * Whether skills HTTP endpoints are enabled.
+     * @default false (opt-in feature)
+     */
+    enabled?: boolean;
+    /**
+     * Prefix for all skills HTTP endpoints.
+     * @example '/api' results in '/api/llm.txt', '/api/skills', etc.
+     */
+    prefix?: string;
+    /**
+     * Authentication mode for all skills HTTP endpoints.
+     * This single setting applies to /llm.txt, /llm_full.txt, and /skills.
+     *
+     * - 'inherit': Use the server's default authentication (default)
+     * - 'public': No authentication required
+     * - 'api-key': Require API key in X-API-Key header
+     * - 'bearer': Require bearer token in Authorization header
+     *
+     * @default 'inherit'
+     */
+    auth?: SkillsConfigAuthMode;
+    /**
+     * API keys for 'api-key' authentication mode.
+     * Only used when auth is 'api-key'.
+     * Requests must include one of these keys in the X-API-Key header
+     * or in Authorization header as `ApiKey <key>`.
+     */
+    apiKeys?: string[];
+    /**
+     * JWT validation configuration for 'bearer' authentication mode.
+     * Required when auth is 'bearer'.
+     *
+     * @example
+     * ```typescript
+     * @FrontMcp({
+     *   skillsConfig: {
+     *     enabled: true,
+     *     auth: 'bearer',
+     *     jwt: {
+     *       issuer: 'https://auth.example.com',
+     *       audience: 'skills-api',
+     *     },
+     *   },
+     * })
+     * ```
+     */
+    jwt?: SkillsConfigJwtOptions;
+    /**
+     * Configuration for /llm.txt endpoint.
+     * Provides compact skill summaries (name, description, tools, tags).
+     *
+     * Can be:
+     * - `true`: Enable with defaults
+     * - `false`: Disable this endpoint
+     * - `{ enabled?: boolean; path?: string }`: Custom configuration
+     *
+     * @default true (when skillsConfig.enabled is true)
+     */
+    llmTxt?: SkillsConfigEndpointConfig | boolean;
+    /**
+     * Configuration for /llm_full.txt endpoint.
+     * Provides full skill content with complete instructions and tool schemas.
+     *
+     * Can be:
+     * - `true`: Enable with defaults
+     * - `false`: Disable this endpoint
+     * - `{ enabled?: boolean; path?: string }`: Custom configuration
+     *
+     * @default true (when skillsConfig.enabled is true)
+     */
+    llmFullTxt?: SkillsConfigEndpointConfig | boolean;
+    /**
+     * Configuration for /skills API endpoints.
+     * Provides JSON API for listing, searching, and loading skills.
+     *
+     * Endpoints:
+     * - GET /skills - List all skills
+     * - GET /skills?query=X - Search skills
+     * - GET /skills/{id} - Get specific skill by ID/name
+     *
+     * Can be:
+     * - `true`: Enable with defaults
+     * - `false`: Disable this endpoint
+     * - `{ enabled?: boolean; path?: string }`: Custom configuration
+     *
+     * @default true (when skillsConfig.enabled is true)
+     */
+    api?: SkillsConfigEndpointConfig | boolean;
+    /**
+     * Whether to include searchSkills/loadSkill MCP tools.
+     * Set to false to expose skills only via HTTP endpoints.
+     *
+     * @default true
+     */
+    mcpTools?: boolean;
+    /**
+     * Cache configuration for HTTP endpoints.
+     * Reduces latency and CPU/memory overhead for repeated requests.
+     *
+     * @example Memory cache (default)
+     * ```typescript
+     * cache: { enabled: true, ttlMs: 30000 }
+     * ```
+     *
+     * @example Redis cache
+     * ```typescript
+     * cache: {
+     *   enabled: true,
+     *   redis: { provider: 'redis', host: 'localhost' },
+     *   ttlMs: 60000,
+     * }
+     * ```
+     */
+    cache?: SkillsConfigCacheOptions;
+}
+/**
+ * Cache configuration for skills HTTP endpoints.
+ */
+export interface SkillsConfigCacheOptions {
+    /**
+     * Whether caching is enabled.
+     * @default false (opt-in)
+     */
+    enabled?: boolean;
+    /**
+     * Redis configuration for distributed caching.
+     * If not provided, falls back to in-memory cache.
+     *
+     * Note: 'redis' provider uses ioredis under the hood.
+     */
+    redis?: {
+        /** Redis provider type */
+        provider: 'redis' | 'vercel-kv' | '@vercel/kv';
+        /** Redis host */
+        host?: string;
+        /** Redis port */
+        port?: number;
+        /** Redis password */
+        password?: string;
+        /** Redis database number */
+        db?: number;
+    };
+    /**
+     * Cache TTL in milliseconds.
+     * @default 60000 (1 minute)
+     */
+    ttlMs?: number;
+    /**
+     * Key prefix for Redis cache.
+     * @default 'frontmcp:skills:cache:'
+     */
+    keyPrefix?: string;
+}
+//# sourceMappingURL=interfaces.d.ts.map

package/common/types/options/skills-http/interfaces.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"interfaces.d.ts","sourceRoot":"","sources":["../../../../../src/common/types/options/skills-http/interfaces.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiEG;AAEH;;;;;;GAMG;AACH,MAAM,MAAM,oBAAoB,GAAG,SAAS,GAAG,QAAQ,GAAG,SAAS,GAAG,QAAQ,CAAC;AAE/E;;GAEG;AACH,MAAM,WAAW,sBAAsB;IACrC;;;OAGG;IACH,MAAM,EAAE,MAAM,CAAC;IAEf;;;OAGG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAElB;;;OAGG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED;;;;GAIG;AACH,MAAM,WAAW,0BAA0B;IACzC;;;OAGG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;IAElB;;;OAGG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqDG;AACH,MAAM,WAAW,mBAAmB;IAClC;;;OAGG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;IAElB;;;OAGG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAEhB;;;;;;;;;;OAUG;IACH,IAAI,CAAC,EAAE,oBAAoB,CAAC;IAE5B;;;;;OAKG;IACH,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IAEnB;;;;;;;;;;;;;;;;;OAiBG;IACH,GAAG,CAAC,EAAE,sBAAsB,CAAC;IAE7B;;;;;;;;;;OAUG;IACH,MAAM,CAAC,EAAE,0BAA0B,GAAG,OAAO,CAAC;IAE9C;;;;;;;;;;OAUG;IACH,UAAU,CAAC,EAAE,0BAA0B,GAAG,OAAO,CAAC;IAElD;;;;;;;;;;;;;;;OAeG;IACH,GAAG,CAAC,EAAE,0BAA0B,GAAG,OAAO,CAAC;IAE3C;;;;;OAKG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAC;IAEnB;;;;;;;;;;;;;;;;;OAiBG;IACH,KAAK,CAAC,EAAE,wBAAwB,CAAC;CAClC;AAED;;GAEG;AACH,MAAM,WAAW,wBAAwB;IACvC;;;OAGG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;IAElB;;;;;OAKG;IACH,KAAK,CAAC,EAAE;QACN,0BAA0B;QAC1B,QAAQ,EAAE,OAAO,GAAG,WAAW,GAAG,YAAY,CAAC;QAC/C,iBAAiB;QACjB,IAAI,CAAC,EAAE,MAAM,CAAC;QACd,iBAAiB;QACjB,IAAI,CAAC,EAAE,MAAM,CAAC;QACd,qBAAqB;QACrB,QAAQ,CAAC,EAAE,MAAM,CAAC;QAClB,4BAA4B;QAC5B,EAAE,CAAC,EAAE,MAAM,CAAC;KACb,CAAC;IAEF;;;OAGG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;IAEf;;;OAGG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB"}

package/common/types/options/skills-http/schema.d.ts

@@ -0,0 +1,139 @@
+import { z } from 'zod';
+import type { SkillsConfigAuthMode } from './interfaces';
+/**
+ * Authentication mode schema for skills HTTP endpoints.
+ */
+export declare const skillsConfigAuthModeSchema: z.ZodEnum<{
+    bearer: "bearer";
+    public: "public";
+    inherit: "inherit";
+    "api-key": "api-key";
+}>;
+/**
+ * Endpoint configuration schema (simplified - no auth, just enabled and path).
+ */
+export declare const skillsConfigEndpointConfigSchema: z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    path: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * JWT validation configuration schema.
+ */
+export declare const skillsConfigJwtOptionsSchema: z.ZodObject<{
+    issuer: z.ZodString;
+    audience: z.ZodOptional<z.ZodString>;
+    jwksUrl: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * Cache configuration schema.
+ *
+ * Supports 'redis' (uses ioredis under the hood) and 'vercel-kv' providers.
+ */
+export declare const skillsConfigCacheOptionsSchema: z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    redis: z.ZodOptional<z.ZodObject<{
+        provider: z.ZodEnum<{
+            redis: "redis";
+            "vercel-kv": "vercel-kv";
+            "@vercel/kv": "@vercel/kv";
+        }>;
+        host: z.ZodOptional<z.ZodString>;
+        port: z.ZodOptional<z.ZodNumber>;
+        password: z.ZodOptional<z.ZodString>;
+        db: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    ttlMs: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+    keyPrefix: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * Skills HTTP options Zod schema.
+ * Auth is configured at the top level and applies to all HTTP endpoints.
+ */
+export declare const skillsConfigOptionsSchema: z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    prefix: z.ZodOptional<z.ZodString>;
+    auth: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+        bearer: "bearer";
+        public: "public";
+        inherit: "inherit";
+        "api-key": "api-key";
+    }>>>;
+    apiKeys: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    jwt: z.ZodOptional<z.ZodObject<{
+        issuer: z.ZodString;
+        audience: z.ZodOptional<z.ZodString>;
+        jwksUrl: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    llmTxt: z.ZodDefault<z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        path: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodBoolean]>>>;
+    llmFullTxt: z.ZodDefault<z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        path: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodBoolean]>>>;
+    api: z.ZodDefault<z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        path: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodBoolean]>>>;
+    mcpTools: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    cache: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        redis: z.ZodOptional<z.ZodObject<{
+            provider: z.ZodEnum<{
+                redis: "redis";
+                "vercel-kv": "vercel-kv";
+                "@vercel/kv": "@vercel/kv";
+            }>;
+            host: z.ZodOptional<z.ZodString>;
+            port: z.ZodOptional<z.ZodNumber>;
+            password: z.ZodOptional<z.ZodString>;
+            db: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+        ttlMs: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
+        keyPrefix: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+/**
+ * Skills HTTP options type (with defaults applied).
+ */
+export type SkillsConfigOptions = z.infer<typeof skillsConfigOptionsSchema>;
+/**
+ * Skills HTTP options input type (for user configuration).
+ */
+export type SkillsConfigOptionsInput = z.input<typeof skillsConfigOptionsSchema>;
+/**
+ * Skills HTTP endpoint config type (with defaults applied).
+ */
+export type SkillsConfigEndpointConfig = z.infer<typeof skillsConfigEndpointConfigSchema>;
+/**
+ * Skills HTTP endpoint config input type.
+ */
+export type SkillsConfigEndpointConfigInput = z.input<typeof skillsConfigEndpointConfigSchema>;
+/**
+ * Normalized endpoint configuration with auth from parent.
+ * This is the result of normalizing an endpoint config with the parent's auth settings.
+ */
+export interface NormalizedEndpointConfig {
+    enabled: boolean;
+    path: string;
+    auth: SkillsConfigAuthMode;
+    apiKeys?: string[];
+}
+/**
+ * Normalize endpoint configuration.
+ * Converts boolean or config object to normalized config object.
+ * Auth settings come from the parent skillsConfig, not per-endpoint.
+ */
+export declare function normalizeEndpointConfig(config: boolean | SkillsConfigEndpointConfig | undefined, defaultPath: string, parentAuth: SkillsConfigAuthMode, parentApiKeys?: string[]): NormalizedEndpointConfig;
+/**
+ * Normalize skills HTTP options.
+ * Applies defaults and normalizes all endpoint configurations.
+ * Auth is applied from the top level to all endpoints.
+ */
+export declare function normalizeSkillsConfigOptions(options: SkillsConfigOptionsInput | undefined): SkillsConfigOptions & {
+    normalizedLlmTxt: NormalizedEndpointConfig;
+    normalizedLlmFullTxt: NormalizedEndpointConfig;
+    normalizedApi: NormalizedEndpointConfig;
+};
+//# sourceMappingURL=schema.d.ts.map

package/common/types/options/skills-http/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../../../src/common/types/options/skills-http/schema.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AACxB,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,cAAc,CAAC;AAEzD;;GAEG;AACH,eAAO,MAAM,0BAA0B;;;;;EAAqD,CAAC;AAE7F;;GAEG;AACH,eAAO,MAAM,gCAAgC;;;iBAG3C,CAAC;AAOH;;GAEG;AACH,eAAO,MAAM,4BAA4B;;;;iBAIvC,CAAC;AAEH;;;;GAIG;AACH,eAAO,MAAM,8BAA8B;;;;;;;;;;;;;;;iBAazC,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAWpC,CAAC;AAEH;;GAEG;AACH,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAE5E;;GAEG;AACH,MAAM,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAEjF;;GAEG;AACH,MAAM,MAAM,0BAA0B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gCAAgC,CAAC,CAAC;AAE1F;;GAEG;AACH,MAAM,MAAM,+BAA+B,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gCAAgC,CAAC,CAAC;AAE/F;;;GAGG;AACH,MAAM,WAAW,wBAAwB;IACvC,OAAO,EAAE,OAAO,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,oBAAoB,CAAC;IAC3B,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;CACpB;AAED;;;;GAIG;AACH,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,OAAO,GAAG,0BAA0B,GAAG,SAAS,EACxD,WAAW,EAAE,MAAM,EACnB,UAAU,EAAE,oBAAoB,EAChC,aAAa,CAAC,EAAE,MAAM,EAAE,GACvB,wBAAwB,CAuB1B;AAED;;;;GAIG;AACH,wBAAgB,4BAA4B,CAAC,OAAO,EAAE,wBAAwB,GAAG,SAAS,GAAG,mBAAmB,GAAG;IACjH,gBAAgB,EAAE,wBAAwB,CAAC;IAC3C,oBAAoB,EAAE,wBAAwB,CAAC;IAC/C,aAAa,EAAE,wBAAwB,CAAC;CACzC,CAsBA"}

package/common/types/options/transport/index.d.ts

@@ -0,0 +1,4 @@
+export type { TransportOptionsInterface, TransportOptionsInput, ProtocolConfig, ProtocolPreset, PersistenceConfig, EventStoreConfig, SessionMode, SessionModeOption, PlatformMappingEntry, PlatformDetectionConfig, DistributedEnabled, } from './interfaces';
+export { transportOptionsSchema, persistenceConfigSchema, eventStoreConfigSchema, PROTOCOL_PRESETS, expandProtocolConfig, toLegacyProtocolFlags, isDistributedMode, shouldCacheProviders, expandTransportConfig, } from './schema';
+export type { TransportOptions, TransportPersistenceConfig, TransportPersistenceConfigInput, PlatformDetectionConfigType, DistributedConfigInput, LegacyProtocolFlags, ExpandedTransportConfig, } from './schema';
+//# sourceMappingURL=index.d.ts.map

package/common/types/options/transport/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/common/types/options/transport/index.ts"],"names":[],"mappings":"AAMA,YAAY,EAEV,yBAAyB,EACzB,qBAAqB,EAErB,cAAc,EACd,cAAc,EAEd,iBAAiB,EAEjB,gBAAgB,EAEhB,WAAW,EACX,iBAAiB,EACjB,oBAAoB,EACpB,uBAAuB,EAEvB,kBAAkB,GACnB,MAAM,cAAc,CAAC;AAKtB,OAAO,EAEL,sBAAsB,EAEtB,uBAAuB,EACvB,sBAAsB,EAEtB,gBAAgB,EAEhB,oBAAoB,EACpB,qBAAqB,EACrB,iBAAiB,EACjB,oBAAoB,EACpB,qBAAqB,GACtB,MAAM,UAAU,CAAC;AAElB,YAAY,EAEV,gBAAgB,EAChB,0BAA0B,EAC1B,+BAA+B,EAC/B,2BAA2B,EAC3B,sBAAsB,EAEtB,mBAAmB,EACnB,uBAAuB,GACxB,MAAM,UAAU,CAAC"}