@caplets/core 0.19.0 → 0.20.0

package/dist/{completion-brgziz4L.js → completion-CbazRAiL.js}

@@ -1,5 +1,5 @@
-import { Bt as DEFAULT_COMPLETION_CACHE_DIR, Gt as resolveConfigPath, Pt as loadConfigWithSources, Wt as resolveCapletsRoot, en as __exportAll, qt as resolveProjectConfigPath, zt as DEFAULT_AUTH_DIR } from "./service-BXcE4Rv8.js";
-import { u as CapletsError } from "./validation-BBG4skZf.js";
+import { St as resolveProjectConfigPath, Y as loadConfigWithSources, bt as resolveConfigPath, mt as DEFAULT_COMPLETION_CACHE_DIR, pt as DEFAULT_AUTH_DIR, vn as __exportAll, yt as resolveCapletsRoot } from "./service-D0MwLNyb.js";
+import { u as CapletsError } from "./validation-CdqbI2zN.js";
 import { mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { createHash } from "node:crypto";
@@ -14,6 +14,7 @@ const completionShells = [
 const cliCommands = {
 	completion: "completion",
 	completeHidden: "__complete",
+	codeMode: "code-mode",
 	serve: "serve",
 	attach: "attach",
 	cloud: "cloud",
@@ -42,6 +43,7 @@ const cliCommands = {
 };
 const topLevelCommandNames = [
 	cliCommands.serve,
+	cliCommands.codeMode,
 	cliCommands.attach,
 	cliCommands.cloud,
 	cliCommands.init,
@@ -82,6 +84,7 @@ const cliSubcommands = {
 		"list"
 	],
 	[cliCommands.cloud]: ["auth"],
+	[cliCommands.codeMode]: ["types"],
 	[cliCommands.completion]: [...completionShells],
 	[cliCommands.config]: ["path", "paths"],
 	[cliCommands.serve]: [

package/dist/config/paths.d.ts

@@ -6,9 +6,11 @@ export declare function defaultCacheBaseDir(env?: PathEnv, home?: string, platfo
 export declare function defaultConfigPath(env?: PathEnv, home?: string, platform?: Platform): string;
 export declare function defaultAuthDir(env?: PathEnv, home?: string, platform?: Platform): string;
 export declare function defaultCompletionCacheDir(env?: PathEnv, home?: string, platform?: Platform): string;
+export declare function defaultObservedOutputShapeCacheDir(env?: PathEnv, home?: string, platform?: Platform): string;
 export declare const DEFAULT_CONFIG_PATH: string;
 export declare const DEFAULT_AUTH_DIR: string;
 export declare const DEFAULT_COMPLETION_CACHE_DIR: string;
+export declare const DEFAULT_OBSERVED_OUTPUT_SHAPE_CACHE_DIR: string;
 export declare const PROJECT_CONFIG_FILE: string;
 export declare function resolveConfigPath(path?: string): string;
 export declare function resolveProjectConfigPath(cwd?: string): string;

package/dist/config-runtime.d.ts

@@ -44,6 +44,11 @@ export type RuntimeRequirementsConfig = {
         class?: RuntimeResourceClass | undefined;
     } | undefined;
 };
+export type AgentSelectionHintsConfig = {
+    useWhen?: string | undefined;
+    avoidWhen?: string | undefined;
+};
+export type CapletExposure = "direct" | "progressive" | "code_mode" | "direct_and_code_mode" | "progressive_and_code_mode";
 export type CapletServerConfig = CommonCapletConfig & {
     backend: "mcp";
     transport: "stdio" | "http" | "sse";
@@ -67,7 +72,7 @@ export type OpenApiEndpointConfig = CommonCapletConfig & {
     requestTimeoutMs: number;
     operationCacheTtlMs: number;
 };
-export type GraphQlOperationConfig = {
+export type GraphQlOperationConfig = AgentSelectionHintsConfig & {
     document?: string | undefined;
     documentPath?: string | undefined;
     operationName?: string | undefined;
@@ -85,7 +90,7 @@ export type GraphQlEndpointConfig = CommonCapletConfig & {
     operationCacheTtlMs: number;
     selectionDepth: number;
 };
-export type HttpActionConfig = {
+export type HttpActionConfig = AgentSelectionHintsConfig & {
     method: "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
     path: string;
     description?: string | undefined;
@@ -103,7 +108,7 @@ export type HttpApiConfig = CommonCapletConfig & {
     requestTimeoutMs: number;
     maxResponseBytes: number;
 };
-export type CliToolActionConfig = {
+export type CliToolActionConfig = AgentSelectionHintsConfig & {
     description?: string | undefined;
     inputSchema?: Record<string, unknown> | undefined;
     outputSchema?: Record<string, unknown> | undefined;
@@ -145,6 +150,9 @@ export type CapletsConfig = {
     options: {
         defaultSearchLimit: number;
         maxSearchLimit: number;
+        exposure: CapletExposure;
+        exposureDiscoveryTimeoutMs: number;
+        exposureDiscoveryConcurrency: number;
         completion: {
             discoveryTimeoutMs: number;
             overallTimeoutMs: number;
@@ -159,10 +167,11 @@ export type CapletsConfig = {
     cliTools: Record<string, CliToolsConfig>;
     capletSets: Record<string, CapletSetConfig>;
 };
-type CommonCapletConfig = {
+type CommonCapletConfig = AgentSelectionHintsConfig & {
     server: string;
     name: string;
     description: string;
+    exposure?: CapletExposure | undefined;
     tags?: string[] | undefined;
     body?: string | undefined;
     setup?: CapletSetupConfig | undefined;

package/dist/config-runtime.js

@@ -1,5 +1,5 @@
-import { a as isAllowedHttpBaseUrl, c as validateHttpActionHeaders, i as SERVER_ID_PATTERN, n as HEADER_NAME_PATTERN, o as isAllowedRemoteUrl, r as HTTP_BASE_URL_PATTERN, s as isUrl, t as FORBIDDEN_HEADERS, u as CapletsError } from "./validation-BBG4skZf.js";
 import { _ as record, b as unknown, d as literal, l as discriminatedUnion, m as object, o as array, p as number, r as _enum, s as boolean, v as string, y as union } from "./schemas-BZ6BBrh7.js";
+import { a as isAllowedHttpBaseUrl, c as validateHttpActionHeaders, i as SERVER_ID_PATTERN, n as HEADER_NAME_PATTERN, o as isAllowedRemoteUrl, r as HTTP_BASE_URL_PATTERN, s as isUrl, t as FORBIDDEN_HEADERS, u as CapletsError } from "./validation-CdqbI2zN.js";
 //#region src/config-runtime.ts
 const stringMapSchema = record(string(), string());
 const authSchema = discriminatedUnion("type", [
@@ -37,10 +37,24 @@ const runtimeRequirementsSchema = object({
 		"heavy"
 	]).optional() }).strict().optional()
 }).strict();
+const agentSelectionHintSchema = string().trim().min(1).max(500);
+const agentSelectionHintsSchema = {
+	useWhen: agentSelectionHintSchema.optional(),
+	avoidWhen: agentSelectionHintSchema.optional()
+};
+const exposureSchema = _enum([
+	"direct",
+	"progressive",
+	"code_mode",
+	"direct_and_code_mode",
+	"progressive_and_code_mode"
+]);
 const commonSchema = {
 	name: string().trim().min(1).max(80),
 	description: string().refine((value) => value.trim().length >= 10, "description must contain at least 10 non-whitespace characters").refine((value) => value.length <= 1500, "description must be at most 1500 characters"),
 	tags: array(string().trim().min(1).max(80)).optional(),
+	exposure: exposureSchema.optional(),
+	...agentSelectionHintsSchema,
 	body: string().optional(),
 	setup: setupSchema.optional(),
 	projectBinding: projectBindingSchema.optional(),
@@ -77,7 +91,8 @@ const graphQlOperationSchema = object({
 	document: string().min(1).optional(),
 	documentPath: string().min(1).optional(),
 	operationName: string().min(1).optional(),
-	description: string().min(1).optional()
+	description: string().min(1).optional(),
+	...agentSelectionHintsSchema
 }).strict().refine((operation) => Boolean(operation.document) !== Boolean(operation.documentPath), { message: "GraphQL operation must define exactly one document source" });
 const graphQlEndpointSchema = object({
 	...commonSchema,
@@ -106,6 +121,7 @@ const httpActionSchema = object({
 	]),
 	path: string().min(1).regex(/^\//, "HTTP action path must start with /").refine((value) => !value.startsWith("//"), "HTTP action path must not start with //").refine((value) => !isUrl(value), "HTTP action path must be a URL path, not a URL"),
 	description: string().min(1).optional(),
+	...agentSelectionHintsSchema,
 	inputSchema: record(string(), unknown()).optional(),
 	outputSchema: record(string(), unknown()).optional(),
 	query: scalarMapSchema.optional(),
@@ -125,6 +141,7 @@ const httpApiSchema = object({
 }).strict();
 const cliActionSchema = object({
 	description: string().min(1).optional(),
+	...agentSelectionHintsSchema,
 	inputSchema: record(string(), unknown()).optional(),
 	outputSchema: record(string(), unknown()).optional(),
 	command: string().min(1),
@@ -172,6 +189,15 @@ const configSchema = object({
 		cacheTtlMs: 3e5,
 		negativeCacheTtlMs: 3e4
 	}),
+	options: object({
+		exposure: exposureSchema.default("code_mode"),
+		exposureDiscoveryTimeoutMs: number().int().positive().default(15e3),
+		exposureDiscoveryConcurrency: number().int().positive().max(32).default(4)
+	}).strict().default({
+		exposure: "code_mode",
+		exposureDiscoveryTimeoutMs: 15e3,
+		exposureDiscoveryConcurrency: 4
+	}),
 	mcpServers: record(string().regex(SERVER_ID_PATTERN), mcpServerSchema).default({}),
 	openapiEndpoints: record(string().regex(SERVER_ID_PATTERN), openApiEndpointSchema).default({}),
 	graphqlEndpoints: record(string().regex(SERVER_ID_PATTERN), graphQlEndpointSchema).default({}),
@@ -195,6 +221,9 @@ function parseConfig(input) {
 		options: {
 			defaultSearchLimit: config.defaultSearchLimit,
 			maxSearchLimit: config.maxSearchLimit,
+			exposure: config.options.exposure,
+			exposureDiscoveryTimeoutMs: config.options.exposureDiscoveryTimeoutMs,
+			exposureDiscoveryConcurrency: config.options.exposureDiscoveryConcurrency,
 			completion: config.completion
 		},
 		mcpServers: mapBackend(config.mcpServers, "mcp", (id, raw) => {

package/dist/config.d.ts

@@ -59,11 +59,17 @@ export type RuntimeRequirementsConfig = {
         class?: RuntimeResourceClass | undefined;
     } | undefined;
 };
-export type CapletServerConfig = {
+export type AgentSelectionHintsConfig = {
+    useWhen?: string | undefined;
+    avoidWhen?: string | undefined;
+};
+export type CapletExposure = "direct" | "progressive" | "code_mode" | "direct_and_code_mode" | "progressive_and_code_mode";
+export type CapletServerConfig = AgentSelectionHintsConfig & {
     server: string;
     backend: "mcp";
     name: string;
     description: string;
+    exposure?: CapletExposure | undefined;
     tags?: string[] | undefined;
     body?: string | undefined;
     transport: "stdio" | "http" | "sse";
@@ -92,11 +98,12 @@ export type OpenApiAuthConfig = {
 } | Extract<RemoteAuthConfig, {
     type: "oauth2" | "oidc";
 }>;
-export type OpenApiEndpointConfig = {
+export type OpenApiEndpointConfig = AgentSelectionHintsConfig & {
     server: string;
     backend: "openapi";
     name: string;
     description: string;
+    exposure?: CapletExposure | undefined;
     tags?: string[] | undefined;
     body?: string | undefined;
     specPath?: string | undefined;
@@ -110,17 +117,18 @@ export type OpenApiEndpointConfig = {
     projectBinding?: ProjectBindingConfig | undefined;
     runtime?: RuntimeRequirementsConfig | undefined;
 };
-export type GraphQlOperationConfig = {
+export type GraphQlOperationConfig = AgentSelectionHintsConfig & {
     document?: string | undefined;
     documentPath?: string | undefined;
     operationName?: string | undefined;
     description?: string | undefined;
 };
-export type GraphQlEndpointConfig = {
+export type GraphQlEndpointConfig = AgentSelectionHintsConfig & {
     server: string;
     backend: "graphql";
     name: string;
     description: string;
+    exposure?: CapletExposure | undefined;
     tags?: string[] | undefined;
     body?: string | undefined;
     endpointUrl: string;
@@ -137,7 +145,7 @@ export type GraphQlEndpointConfig = {
     projectBinding?: ProjectBindingConfig | undefined;
     runtime?: RuntimeRequirementsConfig | undefined;
 };
-export type HttpActionConfig = {
+export type HttpActionConfig = AgentSelectionHintsConfig & {
     method: "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
     path: string;
     description?: string | undefined;
@@ -147,11 +155,12 @@ export type HttpActionConfig = {
     headers?: Record<string, string | number | boolean> | undefined;
     jsonBody?: unknown;
 };
-export type HttpApiConfig = {
+export type HttpApiConfig = AgentSelectionHintsConfig & {
     server: string;
     backend: "http";
     name: string;
     description: string;
+    exposure?: CapletExposure | undefined;
     tags?: string[] | undefined;
     body?: string | undefined;
     baseUrl: string;
@@ -167,7 +176,7 @@ export type HttpApiConfig = {
 export type CliToolOutputConfig = {
     type: "text" | "json";
 };
-export type CliToolActionConfig = {
+export type CliToolActionConfig = AgentSelectionHintsConfig & {
     description?: string | undefined;
     inputSchema?: Record<string, unknown> | undefined;
     outputSchema?: Record<string, unknown> | undefined;
@@ -185,11 +194,12 @@ export type CliToolActionConfig = {
         openWorldHint?: boolean | undefined;
     } | undefined;
 };
-export type CliToolsConfig = {
+export type CliToolsConfig = AgentSelectionHintsConfig & {
     server: string;
     backend: "cli";
     name: string;
     description: string;
+    exposure?: CapletExposure | undefined;
     tags?: string[] | undefined;
     body?: string | undefined;
     actions: Record<string, CliToolActionConfig>;
@@ -202,11 +212,12 @@ export type CliToolsConfig = {
     projectBinding?: ProjectBindingConfig | undefined;
     runtime?: RuntimeRequirementsConfig | undefined;
 };
-export type CapletSetConfig = {
+export type CapletSetConfig = AgentSelectionHintsConfig & {
     server: string;
     backend: "caplets";
     name: string;
     description: string;
+    exposure?: CapletExposure | undefined;
     tags?: string[] | undefined;
     body?: string | undefined;
     configPath?: string | undefined;
@@ -223,6 +234,9 @@ export type CapletConfig = CapletServerConfig | OpenApiEndpointConfig | GraphQlE
 export type CapletsOptions = {
     defaultSearchLimit: number;
     maxSearchLimit: number;
+    exposure: CapletExposure;
+    exposureDiscoveryTimeoutMs: number;
+    exposureDiscoveryConcurrency: number;
     completion: CompletionConfig;
 };
 export type CompletionConfig = {
@@ -270,6 +284,17 @@ export declare const configFileSchema: z.ZodObject<{
         cacheTtlMs: z.ZodDefault<z.ZodNumber>;
         negativeCacheTtlMs: z.ZodDefault<z.ZodNumber>;
     }, z.core.$strict>>;
+    options: z.ZodDefault<z.ZodObject<{
+        exposure: z.ZodDefault<z.ZodEnum<{
+            direct: "direct";
+            progressive: "progressive";
+            code_mode: "code_mode";
+            direct_and_code_mode: "direct_and_code_mode";
+            progressive_and_code_mode: "progressive_and_code_mode";
+        }>>;
+        exposureDiscoveryTimeoutMs: z.ZodDefault<z.ZodNumber>;
+        exposureDiscoveryConcurrency: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strict>>;
     mcpServers: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
     openapiEndpoints: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;
     graphqlEndpoints: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>>;

package/dist/downstream.d.ts

@@ -2,11 +2,23 @@ import { type Prompt, type Resource, type ResourceTemplate as McpResourceTemplat
 import type { CapletServerConfig } from "./config";
 import type { ServerRegistry } from "./registry";
 export type CompactTool = {
-    id: string;
-    tool: string;
+    name: string;
     description?: string;
+    useWhen?: string;
+    avoidWhen?: string;
     hasInputSchema: boolean;
     hasOutputSchema: boolean;
+    supportsFields: boolean;
+    requiredArgs?: string[];
+    acceptedArgs?: string[];
+    argsTemplate?: Record<string, unknown>;
+    callTemplate?: {
+        operation: "call_tool";
+        name: string;
+        args: Record<string, unknown>;
+    };
+    readOnlyHint?: boolean;
+    destructiveHint?: boolean;
 };
 export type CompactResource = {
     id: string;
@@ -202,8 +214,14 @@ export declare class DownstreamManager {
     private isCacheFresh;
     private refreshTools;
     private connect;
+    private connectionStartError;
+    private markConnectionStartUnavailable;
+    private startConnection;
     private createTransport;
     private oauthProvider;
     private currentServer;
     private currentServerFingerprint;
 }
+export declare function compactToolSafetyHints(tool: Tool): Pick<CompactTool, "readOnlyHint" | "destructiveHint">;
+export declare function compactToolSchemaHints(tool: Tool): Pick<CompactTool, "requiredArgs" | "acceptedArgs" | "argsTemplate" | "callTemplate">;
+export declare function compactToolSelectionHints(tool: unknown): Pick<CompactTool, "useWhen" | "avoidWhen">;

package/dist/engine.d.ts

@@ -1,4 +1,6 @@
 import { type CapletConfig, type CapletsConfig } from "./config";
+import { type ObservedOutputShapeKey, type ObservedOutputShapeStore } from "./observed-output-shapes";
+import { type ExposureSnapshot } from "./exposure/discovery";
 export type CapletsEngineOptions = {
     configPath?: string;
     projectConfigPath?: string;
@@ -7,6 +9,10 @@ export type CapletsEngineOptions = {
     watch?: boolean;
     writeErr?: (value: string) => void;
     configLoader?: (configPath: string, projectConfigPath: string) => CapletsConfig;
+    observedOutputShapeStore?: ObservedOutputShapeStore | undefined;
+    observedOutputShapeScope?: ObservedOutputShapeKey["scope"] | undefined;
+    observedOutputShapeCacheDir?: string | undefined;
+    projectFingerprint?: string | undefined;
 };
 export type CapletsEngineReloadEvent = {
     previous: CapletsConfig;
@@ -26,7 +32,11 @@ export declare class CapletsEngine {
     private readonly watchEnabled;
     private readonly writeErr;
     private readonly configLoader;
+    private readonly observedOutputShapeStore;
+    private readonly observedOutputShapeScope;
+    private readonly projectFingerprint;
     private readonly reloadListeners;
+    private lastExposureSnapshot;
     private watchers;
     private reloadTimer;
     private watcherRefreshTimer;
@@ -36,14 +46,24 @@ export declare class CapletsEngine {
     constructor(options?: CapletsEngineOptions);
     currentConfig(): CapletsConfig;
     enabledServers(): CapletConfig[];
+    exposureSnapshot(options?: {
+        discoverNonDirectMcpSurfaces?: boolean | undefined;
+    }): Promise<ExposureSnapshot>;
+    currentExposureSnapshot(): ExposureSnapshot | undefined;
     watchedPaths(): string[];
     onReload(listener: (event: CapletsEngineReloadEvent) => void): () => void;
     scheduleReload(): void;
     reload(): Promise<boolean>;
     execute(serverId: string, request: unknown): Promise<unknown>;
+    executeDirectTool(serverId: string, toolName: string, args: Record<string, unknown>): Promise<unknown>;
+    readDirectResource(serverId: string, downstreamUri: string): Promise<unknown>;
+    getDirectPrompt(serverId: string, promptName: string, args: Record<string, unknown>): Promise<unknown>;
     completeCliWords(words: string[]): Promise<string[]>;
     close(): Promise<void>;
     private listCompletionTools;
+    private listTools;
+    private callTool;
+    private optionalMcpList;
     private reloadOnce;
     private reloadUntilSettled;
     private emitReload;

package/dist/exposure/direct-names.d.ts

@@ -0,0 +1,9 @@
+export declare function directToolName(capletId: string, operationName: string): string;
+export declare function directPromptName(capletId: string, promptName: string): string;
+export declare function nativeDirectToolName(capletId: string, operationName: string): string;
+export declare function directResourceUri(capletId: string, downstreamUri: string): string;
+export declare function directResourceTemplateUri(capletId: string, downstreamUriTemplate: string): string;
+export declare function decodeDirectResourceUri(uri: string): {
+    capletId: string;
+    downstreamUri: string;
+};

package/dist/exposure/discovery.d.ts

@@ -0,0 +1,75 @@
+import type { Prompt, Resource, ResourceTemplate, Tool } from "@modelcontextprotocol/sdk/types";
+import type { CapletConfig, CapletsConfig } from "../config";
+import { type SafeErrorSummary } from "../errors";
+import { type ResolvedExposure } from "./policy";
+export type HiddenCapletReason = "disabled" | "setup_required" | "project_binding_required" | "discovery_failed" | "empty_surface";
+export type HiddenCaplet = {
+    capletId: string;
+    reason: HiddenCapletReason;
+    error?: SafeErrorSummary | undefined;
+};
+export type CallableCaplet = {
+    caplet: CapletConfig;
+    exposure: ResolvedExposure;
+    tools: Tool[];
+    resources: Resource[];
+    resourceTemplates: ResourceTemplate[];
+    prompts: Prompt[];
+    discoveredAt: number;
+};
+export type DirectToolRegistration = {
+    caplet: CapletConfig;
+    downstreamName: string;
+    name: string;
+    tool: Tool;
+};
+export type DirectResourceRegistration = {
+    caplet: Extract<CapletConfig, {
+        backend: "mcp";
+    }>;
+    downstreamUri: string;
+    uri: string;
+    resource: Resource;
+};
+export type DirectResourceTemplateRegistration = {
+    caplet: Extract<CapletConfig, {
+        backend: "mcp";
+    }>;
+    downstreamUriTemplate: string;
+    uriTemplate: string;
+    resourceTemplate: ResourceTemplate;
+};
+export type DirectPromptRegistration = {
+    caplet: Extract<CapletConfig, {
+        backend: "mcp";
+    }>;
+    downstreamName: string;
+    name: string;
+    prompt: Prompt;
+};
+export type ExposureSnapshot = {
+    callableCaplets: CallableCaplet[];
+    progressiveCaplets: CallableCaplet[];
+    codeModeCaplets: CallableCaplet[];
+    directTools: DirectToolRegistration[];
+    directResources: DirectResourceRegistration[];
+    directResourceTemplates: DirectResourceTemplateRegistration[];
+    directPrompts: DirectPromptRegistration[];
+    hiddenCaplets: HiddenCaplet[];
+};
+export type DiscoverExposureSnapshotOptions = {
+    config: CapletsConfig;
+    caplets: CapletConfig[];
+    discoverNonDirectMcpSurfaces?: boolean | undefined;
+    listTools(caplet: CapletConfig): Promise<Tool[]>;
+    listResources?(caplet: Extract<CapletConfig, {
+        backend: "mcp";
+    }>): Promise<Resource[]>;
+    listResourceTemplates?(caplet: Extract<CapletConfig, {
+        backend: "mcp";
+    }>): Promise<ResourceTemplate[]>;
+    listPrompts?(caplet: Extract<CapletConfig, {
+        backend: "mcp";
+    }>): Promise<Prompt[]>;
+};
+export declare function discoverExposureSnapshot(options: DiscoverExposureSnapshotOptions): Promise<ExposureSnapshot>;

package/dist/exposure/policy.d.ts

@@ -0,0 +1,8 @@
+import type { CapletExposure } from "../config";
+export type ResolvedExposure = {
+    value: CapletExposure;
+    direct: boolean;
+    progressive: boolean;
+    codeMode: boolean;
+};
+export declare function resolveExposure(capletExposure: CapletExposure | undefined, globalExposure: CapletExposure): ResolvedExposure;