cdk-local 0.45.0 → 0.47.0

package/dist/internal-CPdFiC6i.d.ts

@@ -0,0 +1,1132 @@
+import { Command, Option } from "commander";
+import { SSMClient } from "@aws-sdk/client-ssm";
+import { WebSocket } from "ws";
+import { IncomingMessage, Server, ServerResponse } from "node:http";
+
+//#region src/types/resource.d.ts
+interface CloudFormationTemplate {
+  AWSTemplateFormatVersion?: string;
+  Description?: string;
+  Parameters?: Record<string, TemplateParameter>;
+  Resources: Record<string, TemplateResource>;
+  Outputs?: Record<string, TemplateOutput>;
+  Conditions?: Record<string, unknown>;
+  Mappings?: Record<string, unknown>;
+  Transform?: unknown;
+  Rules?: Record<string, unknown>;
+}
+interface TemplateParameter {
+  Type: string;
+  Default?: unknown;
+  Description?: string;
+  AllowedValues?: unknown[];
+  AllowedPattern?: string;
+  ConstraintDescription?: string;
+}
+interface TemplateResource {
+  Type: string;
+  Properties?: Record<string, unknown>;
+  DependsOn?: string | readonly string[];
+  Condition?: string;
+  Metadata?: Record<string, unknown>;
+  CreationPolicy?: Record<string, unknown>;
+  UpdatePolicy?: Record<string, unknown>;
+  DeletionPolicy?: 'Delete' | 'Retain' | 'Snapshot';
+  UpdateReplacePolicy?: 'Delete' | 'Retain' | 'Snapshot';
+}
+interface TemplateOutput {
+  Value: unknown;
+  Description?: string;
+  Export?: {
+    Name: string;
+  };
+}
+//#endregion
+//#region src/types/state.d.ts
+interface ResourceState {
+  physicalId: string;
+  resourceType: string;
+  properties: Record<string, unknown>;
+  observedProperties?: Record<string, unknown>;
+  attributes?: Record<string, unknown>;
+  dependencies?: string[];
+  metadata?: Record<string, unknown>;
+  deletionPolicy?: 'Delete' | 'Retain' | 'Snapshot' | 'RetainExceptOnCreate' | undefined;
+  updateReplacePolicy?: 'Delete' | 'Retain' | 'Snapshot' | 'RetainExceptOnCreate' | undefined;
+  provisionedBy?: 'sdk' | 'cc-api' | undefined;
+}
+//#endregion
+//#region src/local/state-resolver.d.ts
+type StateSubstitutionResult = {
+  kind: 'literal';
+  value: string | number | boolean;
+} | {
+  kind: 'unresolved';
+  reason: string;
+};
+interface PseudoParameters {
+  accountId?: string;
+  region?: string;
+  partition?: string;
+  urlSuffix?: string;
+}
+interface CrossStackResolver {
+  resolveImport(exportName: string): Promise<string | undefined>;
+  resolveGetStackOutput(producerStack: string, producerRegion: string, outputName: string): Promise<string | undefined>;
+}
+interface SubstitutionContext {
+  resources: Record<string, ResourceState>;
+  parameters?: Record<string, string>;
+  sensitiveParameters?: ReadonlySet<string>;
+  onSensitiveParameterConsumed?: (logicalId: string) => void;
+  pseudoParameters?: PseudoParameters;
+  crossStackResolver?: CrossStackResolver;
+  consumerRegion?: string;
+}
+declare function substituteAgainstState(value: unknown, contextOrResources: SubstitutionContext | Record<string, ResourceState>): StateSubstitutionResult;
+declare function substituteAgainstStateAsync(value: unknown, contextOrResources: SubstitutionContext | Record<string, ResourceState>): Promise<StateSubstitutionResult>;
+interface StateEnvSubstitutionAudit {
+  resolvedKeys: string[];
+  unresolved: Array<{
+    key: string;
+    reason: string;
+  }>;
+  sensitiveKeys: string[];
+}
+declare function substituteEnvVarsFromState(templateEnv: Record<string, unknown> | undefined, contextOrResources: SubstitutionContext | Record<string, ResourceState>): {
+  env: Record<string, unknown>;
+  audit: StateEnvSubstitutionAudit;
+};
+declare function substituteEnvVarsFromStateAsync(templateEnv: Record<string, unknown> | undefined, contextOrResources: SubstitutionContext | Record<string, ResourceState>): Promise<{
+  env: Record<string, unknown>;
+  audit: StateEnvSubstitutionAudit;
+}>;
+//#endregion
+//#region src/local/ssm-parameter-resolver.d.ts
+interface SsmParameterRef {
+  logicalId: string;
+  ssmName: string;
+  isList: boolean;
+}
+interface ResolvedSsmParameters {
+  values: Record<string, string>;
+  secureStringLogicalIds: string[];
+}
+declare function collectSsmParameterRefs(template: Pick<CloudFormationTemplate, 'Parameters'> | undefined): SsmParameterRef[];
+declare function resolveSsmParameters(client: SSMClient, refs: readonly SsmParameterRef[], label: string): Promise<ResolvedSsmParameters>;
+//#endregion
+//#region src/local/local-state-provider.d.ts
+interface LocalStateRecord {
+  resources: Record<string, ResourceState>;
+  outputs: Record<string, string>;
+  region: string;
+}
+interface LocalStateProvider {
+  readonly label: string;
+  load(stackName: string, synthRegion: string | undefined): Promise<LocalStateRecord | undefined>;
+  buildCrossStackResolver(consumerRegion: string): Promise<CrossStackResolver | undefined>;
+  resolveDeployedFunctionEnv?(functionPhysicalId: string): Promise<Record<string, string> | undefined>;
+  resolveTemplateSsmParameters?(template: CloudFormationTemplate): Promise<ResolvedSsmParameters>;
+  dispose(): void;
+}
+//#endregion
+//#region src/cli/commands/local-state-source.d.ts
+interface LocalStateSourceOptions {
+  fromCfnStack?: string | boolean;
+  region?: string;
+  profile?: string;
+  stackRegion?: string;
+  [key: string]: unknown;
+}
+type LocalStateProviderFactory = (options: LocalStateSourceOptions) => LocalStateProvider;
+type ExtraStateProviders = Record<string, LocalStateProviderFactory>;
+declare function resolveCfnStackName(fromCfnStack: string | boolean, stackName: string): string;
+declare function isCfnFlagPresent(opts: Pick<LocalStateSourceOptions, 'fromCfnStack'>): boolean;
+declare function resolveCfnRegion(options: Pick<LocalStateSourceOptions, 'stackRegion' | 'region'>, synthRegion: string | undefined): string;
+declare function resolveCfnFallbackRegion(options: Pick<LocalStateSourceOptions, 'fromCfnStack' | 'profile'>, synthRegion: string | undefined): Promise<string | undefined>;
+declare class LocalStateSourceError extends Error {
+  constructor(message: string);
+}
+declare function rejectExplicitCfnStackWithMultipleStacks(options: Pick<LocalStateSourceOptions, 'fromCfnStack'>, routedStackCount: number): void;
+declare function createLocalStateProvider(options: LocalStateSourceOptions, stackName: string, synthRegion: string | undefined, extraStateProviders?: ExtraStateProviders): LocalStateProvider | undefined;
+//#endregion
+//#region src/local/embed-config.d.ts
+interface CdkLocalEmbedConfig {
+  cliName?: string;
+  binaryName?: string;
+  productName?: string;
+  resourceNamePrefix?: string;
+  awsBindMountPath?: string;
+  envPrefix?: string;
+  sigV4StrictByDefault?: boolean;
+  sigV4OptFlag?: string;
+}
+interface ResolvedEmbedConfig {
+  cliName: string;
+  binaryName: string;
+  productName: string;
+  resourceNamePrefix: string;
+  awsBindMountPath: string;
+  envPrefix: string;
+  sigV4StrictByDefault: boolean;
+  sigV4OptFlag: string;
+}
+declare function setEmbedConfig(config?: CdkLocalEmbedConfig): void;
+declare function getEmbedConfig(): ResolvedEmbedConfig;
+declare function resetEmbedConfig(): void;
+//#endregion
+//#region src/synthesis/assembly-reader.d.ts
+interface StackInfo {
+  stackName: string;
+  displayName: string;
+  artifactId: string;
+  template: CloudFormationTemplate;
+  assetManifestPath?: string | undefined;
+  dependencyNames: string[];
+  region?: string | undefined;
+  account?: string | undefined;
+  terminationProtection?: boolean | undefined;
+  nestedTemplates?: Record<string, string> | undefined;
+}
+//#endregion
+//#region src/local/lambda-resolver.d.ts
+interface ResolvedArnLambdaLayer {
+  kind: 'arn';
+  logicalId: string;
+  arn: string;
+  region: string;
+  accountId: string;
+  name: string;
+  version: string;
+}
+//#endregion
+//#region src/local/intrinsic-image.d.ts
+interface ImageResolutionContext {
+  pseudoParameters?: {
+    accountId?: string;
+    region?: string;
+    partition?: string;
+    urlSuffix?: string;
+  };
+  stateResources?: Record<string, ResourceState>;
+  stateParameters?: Record<string, string>;
+  stateSensitiveParameters?: readonly string[];
+}
+declare function derivePseudoParametersFromRegion(region: string | undefined, accountId?: string): {
+  accountId?: string;
+  region: string;
+  partition: string;
+  urlSuffix: string;
+} | undefined;
+type FnJoinResolveOutcome = {
+  kind: 'not-applicable';
+} | {
+  kind: 'resolved';
+  uri: string;
+} | {
+  kind: 'needs-state';
+  repoLogicalId: string;
+} | {
+  kind: 'unsupported-join';
+  reason: string;
+};
+declare function tryResolveImageFnJoin(raw: unknown, resources: Record<string, TemplateResource>, context: ImageResolutionContext | undefined): FnJoinResolveOutcome;
+declare function substituteImagePlaceholders(flat: string, resources: Record<string, TemplateResource>, context: ImageResolutionContext | undefined): string;
+//#endregion
+//#region src/local/agentcore-resolver.d.ts
+declare const AGENTCORE_RUNTIME_TYPE = "AWS::BedrockAgentCore::Runtime";
+declare const AGENTCORE_HTTP_PROTOCOL = "HTTP";
+declare const AGENTCORE_MCP_PROTOCOL = "MCP";
+interface ResolvedAgentCoreRuntime {
+  stack: StackInfo;
+  logicalId: string;
+  resource: TemplateResource;
+  containerUri?: string;
+  codeArtifact?: AgentCoreCodeArtifact;
+  environmentVariables: Record<string, unknown>;
+  roleArn?: string;
+  protocol: string;
+  jwtAuthorizer?: AgentCoreJwtAuthorizer;
+}
+interface AgentCoreJwtAuthorizer {
+  discoveryUrl: string;
+  allowedAudience?: string[];
+  allowedClients?: string[];
+}
+interface AgentCoreCodeArtifact {
+  runtime: string;
+  entryPoint: string[];
+  codeAssetHash: string;
+}
+declare class AgentCoreResolutionError extends Error {
+  constructor(message: string);
+}
+declare function resolveAgentCoreTarget(target: string, stacks: StackInfo[], imageContext?: ImageResolutionContext): ResolvedAgentCoreRuntime;
+//#endregion
+//#region src/local/agentcore-client.d.ts
+declare const AGENTCORE_SESSION_ID_HEADER = "X-Amzn-Bedrock-AgentCore-Runtime-Session-Id";
+interface AgentCoreInvokeResult {
+  status: number;
+  contentType: string | null;
+  raw: string;
+  streamed: boolean;
+}
+declare function waitForAgentCorePing(host: string, port: number, timeoutMs?: number): Promise<void>;
+interface InvokeAgentCoreOptions {
+  sessionId: string;
+  timeoutMs: number;
+  authorization?: string;
+  onChunk?: (text: string) => void;
+}
+declare function invokeAgentCore(host: string, port: number, event: unknown, options: InvokeAgentCoreOptions): Promise<AgentCoreInvokeResult>;
+//#endregion
+//#region src/local/agentcore-mcp-client.d.ts
+declare const MCP_CONTAINER_PORT = 8000;
+declare const MCP_PATH = "/mcp";
+declare const MCP_PROTOCOL_VERSION = "2025-06-18";
+interface McpJsonRpcRequest {
+  method: string;
+  params?: unknown;
+}
+interface McpInvokeResult {
+  ok: boolean;
+  raw: string;
+}
+interface McpInvokeOptions {
+  readyTimeoutMs?: number;
+  requestTimeoutMs?: number;
+  fetchImpl?: typeof fetch;
+}
+declare function mcpInvokeOnce(host: string, port: number, request: McpJsonRpcRequest, options?: McpInvokeOptions): Promise<McpInvokeResult>;
+declare function parseSseForJsonRpc(text: string, id: number): unknown;
+//#endregion
+//#region src/local/agentcore-ws-client.d.ts
+interface InvokeAgentCoreWsOptions {
+  sessionId: string;
+  onMessage: (text: string) => void;
+  timeoutMs: number;
+  authorization?: string;
+  webSocketImpl?: typeof WebSocket;
+}
+interface AgentCoreWsResult {
+  frames: number;
+}
+declare function invokeAgentCoreWs(host: string, port: number, event: unknown, options: InvokeAgentCoreWsOptions): Promise<AgentCoreWsResult>;
+//#endregion
+//#region src/local/env-resolver.d.ts
+interface EnvResolutionResult {
+  resolved: Record<string, string>;
+  unresolved: string[];
+}
+interface EnvOverrideFile {
+  Parameters?: Record<string, string | null>;
+  [logicalIdOrDisplayPath: string]: Record<string, string | null> | undefined;
+}
+declare function resolveEnvVars(logicalId: string, displayPath: string | undefined, templateEnv: Record<string, unknown> | undefined, overrides?: EnvOverrideFile): EnvResolutionResult;
+//#endregion
+//#region src/cli/config-loader.d.ts
+interface CdkWatchConfig {
+  include: string[];
+  exclude: string[];
+}
+declare function resolveWatchConfig(): CdkWatchConfig;
+//#endregion
+//#region src/local/httpv2-service-integration.d.ts
+type SupportedSubtype = 'EventBridge-PutEvents' | 'SQS-SendMessage' | 'SQS-ReceiveMessage' | 'SQS-DeleteMessage' | 'SQS-PurgeQueue' | 'Kinesis-PutRecord' | 'StepFunctions-StartExecution' | 'StepFunctions-StartSyncExecution' | 'StepFunctions-StopExecution' | 'AppConfig-GetConfiguration';
+//#endregion
+//#region src/local/container-pool.d.ts
+interface ContainerHandle {
+  logicalId: string;
+  containerId: string;
+  containerName: string;
+  hostPort: number;
+  containerHost: string;
+  stopLogStream: () => void;
+}
+interface ContainerPool {
+  acquire(logicalId: string): Promise<ContainerHandle>;
+  release(handle: ContainerHandle): void;
+  dispose(): Promise<void>;
+}
+//#endregion
+//#region src/local/vtl-engine.d.ts
+declare class VtlEvaluationError extends Error {
+  constructor(message: string);
+}
+//#endregion
+//#region src/local/integration-response-selector.d.ts
+interface IntegrationResponseEntry {
+  StatusCode: string;
+  SelectionPattern?: string;
+  ResponseParameters?: Record<string, string>;
+  ResponseTemplates?: Record<string, string>;
+  ContentHandling?: string;
+}
+interface SelectedIntegrationResponse {
+  entry: IntegrationResponseEntry | null;
+  statusCode: number;
+}
+declare function selectIntegrationResponse(entries: IntegrationResponseEntry[] | undefined, matchTarget: string, fallbackStatusCode?: number): SelectedIntegrationResponse;
+declare function tryParseStatus(raw: unknown): number | undefined;
+declare function evaluateResponseParameters(responseParameters: Record<string, string> | undefined, opts?: {
+  onUnsupported?: (key: string, value: string, reason: string) => void;
+}): Record<string, string>;
+declare function pickResponseTemplate(responseTemplates: Record<string, string> | undefined, accept: string | undefined): {
+  template: string;
+  contentType: string;
+} | undefined;
+//#endregion
+//#region src/local/rest-v1-integrations.d.ts
+interface MockIntegrationConfig {
+  kind: 'mock';
+  requestTemplate: string | undefined;
+  responses: IntegrationResponseEntry[];
+}
+interface HttpProxyIntegrationConfig {
+  kind: 'http-proxy';
+  uri: string;
+  integrationHttpMethod?: string;
+  requestParameters?: Record<string, string>;
+  responses: IntegrationResponseEntry[];
+}
+interface HttpIntegrationConfig {
+  kind: 'http';
+  uri: string;
+  integrationHttpMethod?: string;
+  requestParameters?: Record<string, string>;
+  requestTemplates?: Record<string, string>;
+  responses: IntegrationResponseEntry[];
+}
+interface AwsLambdaIntegrationConfig {
+  kind: 'aws-lambda';
+  lambdaLogicalId: string;
+  requestTemplates?: Record<string, string>;
+  responses: IntegrationResponseEntry[];
+}
+//#endregion
+//#region src/local/route-discovery.d.ts
+type RestV1IntegrationConfig = MockIntegrationConfig | HttpProxyIntegrationConfig | HttpIntegrationConfig | AwsLambdaIntegrationConfig;
+interface DiscoveredRoute {
+  method: string;
+  pathPattern: string;
+  lambdaLogicalId: string;
+  source: 'http-api' | 'rest-v1' | 'function-url';
+  apiVersion: 'v1' | 'v2';
+  stage: string;
+  apiLogicalId?: string;
+  apiStackName?: string;
+  apiCdkPath?: string;
+  stageVariables?: Record<string, string> | null;
+  invokeMode?: 'BUFFERED' | 'RESPONSE_STREAM';
+  unsupported?: {
+    reason: string;
+  };
+  mockCors?: {
+    statusCode: number;
+    headers: Record<string, string>;
+  };
+  serviceIntegration?: {
+    subtype: SupportedSubtype;
+    requestParameters: Readonly<Record<string, unknown>>;
+    responseParameters?: Readonly<Record<string, Readonly<Record<string, string>>>>;
+  };
+  restV1Integration?: RestV1IntegrationConfig;
+  declaredAt: string;
+}
+declare function discoverRoutes(stacks: readonly StackInfo[]): DiscoveredRoute[];
+//#endregion
+//#region src/local/cors-handler.d.ts
+interface CorsConfig {
+  AllowOrigins: string[];
+  AllowMethods: string[];
+  AllowHeaders: string[];
+  ExposeHeaders: string[];
+  MaxAge?: number;
+  AllowCredentials?: boolean;
+}
+declare function buildCorsConfigByApiId(template: CloudFormationTemplate): Map<string, CorsConfig>;
+declare function buildCorsConfigFromCloudFrontChain(template: CloudFormationTemplate): Map<string, CorsConfig>;
+declare function isFunctionUrlOacFronted(template: CloudFormationTemplate, fnUrlLogicalId: string): boolean;
+interface PreflightResponse {
+  statusCode: number;
+  headers: Record<string, string>;
+}
+declare function matchPreflight(req: {
+  method: string;
+  headers: Record<string, string[]>;
+}, config: CorsConfig): PreflightResponse | null;
+declare function applyCorsResponseHeaders(res: ServerResponse, apiLogicalId: string | undefined, corsConfigByApiId: Map<string, CorsConfig>, requestOrigin: string | undefined): void;
+//#endregion
+//#region src/local/authorizer-resolver.d.ts
+interface LambdaTokenAuthorizer {
+  kind: 'lambda-token';
+  logicalId: string;
+  lambdaLogicalId: string;
+  tokenHeader: string;
+  resultTtlSeconds: number;
+  declaredAt: string;
+}
+interface LambdaRequestAuthorizer {
+  kind: 'lambda-request';
+  logicalId: string;
+  lambdaLogicalId: string;
+  identitySources: ReadonlyArray<IdentitySourceSelector>;
+  resultTtlSeconds: number;
+  apiVersion: 'v1' | 'v2';
+  declaredAt: string;
+}
+interface CognitoPoolRef {
+  userPoolArn: string;
+  region: string;
+  userPoolId: string;
+}
+interface CognitoUserPoolAuthorizer {
+  kind: 'cognito';
+  logicalId: string;
+  pools: ReadonlyArray<CognitoPoolRef>;
+  userPoolArn: string;
+  region: string;
+  userPoolId: string;
+  declaredAt: string;
+}
+interface JwtAuthorizer {
+  kind: 'jwt';
+  logicalId: string;
+  issuer: string;
+  audience: ReadonlyArray<string>;
+  region?: string;
+  userPoolId?: string;
+  declaredAt: string;
+}
+interface IamAuthorizer {
+  kind: 'iam';
+  logicalId: 'AWS_IAM';
+  declaredAt: string;
+  oacFronted?: boolean;
+}
+type AuthorizerInfo = LambdaTokenAuthorizer | LambdaRequestAuthorizer | CognitoUserPoolAuthorizer | JwtAuthorizer | IamAuthorizer;
+type IdentitySourceSelector = {
+  kind: 'header';
+  name: string;
+} | {
+  kind: 'query';
+  name: string;
+} | {
+  kind: 'context';
+  name: string;
+} | {
+  kind: 'stage-variable';
+  name: string;
+};
+interface RouteWithAuth {
+  route: DiscoveredRoute;
+  authorizer?: AuthorizerInfo;
+}
+declare function attachAuthorizers(stacks: readonly StackInfo[], routes: readonly DiscoveredRoute[]): RouteWithAuth[];
+//#endregion
+//#region src/local/authorizer-cache.d.ts
+interface CachedAuthorizerResult {
+  allow: boolean;
+  principalId?: string;
+  context?: Record<string, unknown>;
+  policy?: unknown;
+}
+interface AuthorizerCache {
+  get(authorizerLogicalId: string, identityHash: string): CachedAuthorizerResult | undefined;
+  set(authorizerLogicalId: string, identityHash: string, ttlSeconds: number, result: CachedAuthorizerResult): void;
+  clear(): void;
+  size(): number;
+}
+declare function createAuthorizerCache(opts?: {
+  now?: () => number;
+}): AuthorizerCache;
+//#endregion
+//#region src/local/cognito-jwt.d.ts
+interface JwksKey {
+  kid: string;
+  n: string;
+  e: string;
+  alg?: string;
+  kty: string;
+  use?: string;
+}
+interface JwksCacheEntry {
+  byKid: Map<string, JwksKey>;
+  expiresAt: number;
+  passThrough: boolean;
+}
+interface JwksCache {
+  fetchAndCache(jwksUrl: string): Promise<JwksCacheEntry>;
+  peek(jwksUrl: string): JwksCacheEntry | undefined;
+  clear(): void;
+}
+declare function createJwksCache(opts?: {
+  fetchImpl?: (url: string) => Promise<{
+    ok: boolean;
+    status: number;
+    text: () => Promise<string>;
+  }>;
+  now?: () => number;
+  ttlMs?: number;
+  failureTtlMs?: number;
+}): JwksCache;
+declare function buildCognitoJwksUrl(region: string, userPoolId: string): string;
+declare function buildJwksUrlFromIssuer(issuer: string): string;
+declare function verifyCognitoJwt(authorizer: CognitoUserPoolAuthorizer, authorizationHeader: string | undefined, jwksCache: JwksCache, opts?: {
+  now?: () => number;
+  warned?: Set<string>;
+}): Promise<CachedAuthorizerResult & {
+  identityHash: string | undefined;
+  ttlSeconds: number;
+}>;
+declare function verifyJwtAuthorizer(authorizer: JwtAuthorizer, authorizationHeader: string | undefined, jwksCache: JwksCache, opts?: {
+  now?: () => number;
+  warned?: Set<string>;
+}): Promise<CachedAuthorizerResult & {
+  identityHash: string | undefined;
+  ttlSeconds: number;
+}>;
+interface DiscoveryJwtAuthorizer {
+  discoveryUrl: string;
+  allowedAudience?: readonly string[];
+  allowedClients?: readonly string[];
+}
+declare function verifyJwtViaDiscovery(authorizer: DiscoveryJwtAuthorizer, authorizationHeader: string | undefined, jwksCache: JwksCache, opts?: {
+  now?: () => number;
+  warned?: Set<string>;
+  fetchImpl?: (url: string) => Promise<{
+    ok: boolean;
+    status: number;
+    text: () => Promise<string>;
+  }>;
+}): Promise<CachedAuthorizerResult & {
+  identityHash: string | undefined;
+  ttlSeconds: number;
+}>;
+//#endregion
+//#region src/local/sigv4-verify.d.ts
+interface ResolvedCredentials {
+  accessKeyId: string;
+  secretAccessKey: string;
+  sessionToken?: string | undefined;
+}
+type CredentialsLoader = () => Promise<ResolvedCredentials>;
+declare function defaultCredentialsLoader(): CredentialsLoader;
+//#endregion
+//#region src/local/http-server.d.ts
+interface ServerState {
+  routes: readonly RouteWithAuth[];
+  pool: ContainerPool;
+  corsConfigByApiId: Map<string, CorsConfig>;
+}
+interface StartApiServerOptions {
+  state: ServerState;
+  rieTimeoutMs: number;
+  host: string;
+  port: number;
+  authorizerCache?: AuthorizerCache;
+  jwksCache?: JwksCache;
+  jwksWarnedUrls?: Set<string>;
+  mtls?: MtlsServerConfig;
+  sigV4CredentialsLoader?: CredentialsLoader;
+  sigV4WarnedForeignIds?: Set<string>;
+  sigV4Strict?: boolean;
+  defaultRegion?: string;
+  preDispatch?: (req: IncomingMessage, res: ServerResponse) => Promise<boolean>;
+}
+interface MtlsServerConfig {
+  caPem: Buffer;
+  certPem: Buffer;
+  keyPem: Buffer;
+}
+interface StartedApiServer {
+  port: number;
+  host: string;
+  scheme: 'http' | 'https';
+  server: Server;
+  close: () => Promise<void>;
+  setServerState: (next: ServerState) => ServerState;
+  getServerState: () => ServerState;
+}
+declare function startApiServer(opts: StartApiServerOptions): Promise<StartedApiServer>;
+declare function readMtlsMaterialsFromDisk(opts: {
+  truststorePath: string;
+  certPath: string;
+  keyPath: string;
+}): MtlsServerConfig;
+//#endregion
+//#region src/cli/commands/local-start-api.d.ts
+interface CreateLocalStartApiCommandOptions {
+  extraStateProviders?: ExtraStateProviders;
+  embedConfig?: CdkLocalEmbedConfig;
+}
+interface WatchPredicates {
+  ignored: (absPath: string) => boolean;
+  shouldTrigger: (absPath: string) => boolean;
+  excludePatterns: string[];
+}
+declare function createWatchPredicates(args: {
+  watchRoot: string;
+  output: string;
+  watchConfig: CdkWatchConfig;
+}): WatchPredicates;
+interface ApiTargetSubset {
+  readonly filtered: RouteWithAuth[];
+  readonly unmatched: string[];
+}
+declare function resolveApiTargetSubset(routes: readonly RouteWithAuth[], identifiers: readonly string[], stackNames: readonly string[]): ApiTargetSubset;
+declare function createLocalStartApiCommand(opts?: CreateLocalStartApiCommandOptions): Command;
+//#endregion
+//#region src/local/ecs-task-resolver.d.ts
+declare class EcsTaskResolutionError extends Error {
+  constructor(message: string);
+}
+//#endregion
+//#region src/utils/error-handler.d.ts
+declare class CdkLocalError extends Error {
+  readonly code: string;
+  readonly cause: Error | undefined;
+  constructor(message: string, code: string, cause?: Error);
+}
+declare class LocalInvokeBuildError extends CdkLocalError {
+  constructor(message: string, cause?: Error);
+}
+//#endregion
+//#region src/local/intrinsic-utils.d.ts
+declare function pickRefLogicalId(value: unknown): string | null;
+//#endregion
+//#region src/local/intrinsic-lambda-arn.d.ts
+type LambdaArnResolveOutcome = {
+  kind: 'resolved';
+  logicalId: string;
+} | {
+  kind: 'unsupported';
+  detail: string;
+};
+declare function resolveLambdaArnIntrinsic(value: unknown): LambdaArnResolveOutcome;
+//#endregion
+//#region src/local/parameter-mapping.d.ts
+interface RequestParameterContext {
+  headers: Readonly<Record<string, string>>;
+  queryString: Readonly<Record<string, string>>;
+  pathParameters: Readonly<Record<string, string>>;
+  requestPath: string;
+  body: string;
+  context: Readonly<Record<string, string>>;
+  stageVariables: Readonly<Record<string, string>>;
+  authorizer?: Readonly<Record<string, unknown>>;
+}
+type ResolveParametersOutcome = {
+  kind: 'ok';
+  resolved: Record<string, string>;
+} | {
+  kind: 'error';
+  reason: string;
+};
+declare function resolveServiceIntegrationParameters(parameters: Readonly<Record<string, unknown>>, ctx: RequestParameterContext): ResolveParametersOutcome;
+declare function resolveSelectionExpression(input: string, ctx: RequestParameterContext): string;
+//#endregion
+//#region src/local/api-gateway-response.d.ts
+interface TranslatedHttpResponse {
+  statusCode: number;
+  headers: Record<string, string>;
+  cookies: string[];
+  body: Buffer;
+}
+declare function translateLambdaResponse(payload: unknown, version: 'v1' | 'v2'): TranslatedHttpResponse;
+//#endregion
+//#region src/local/docker-inspect.d.ts
+declare function getContainerNetworkIp(containerId: string, networkName: string): Promise<string | undefined>;
+//#endregion
+//#region src/local/route-matcher.d.ts
+interface RouteMatchResult {
+  route: DiscoveredRoute;
+  pathParameters: Record<string, string>;
+}
+declare function matchRoute(method: string, requestPath: string, routes: readonly DiscoveredRoute[]): RouteMatchResult | null;
+//#endregion
+//#region src/local/api-gateway-event.d.ts
+interface HttpRequestSnapshot {
+  method: string;
+  rawUrl: string;
+  headers: Record<string, string[]>;
+  body: Buffer;
+  sourceIp?: string;
+  clientCert?: Record<string, unknown>;
+}
+interface MatchedRouteContext {
+  route: DiscoveredRoute;
+  pathParameters: Record<string, string>;
+  matchedPath: string;
+}
+declare function buildHttpApiV2Event(req: HttpRequestSnapshot, ctx: MatchedRouteContext, opts?: {
+  now?: () => Date;
+}): Record<string, unknown>;
+declare function buildRestV1Event(req: HttpRequestSnapshot, ctx: MatchedRouteContext, opts?: {
+  now?: () => Date;
+}): Record<string, unknown>;
+type AuthorizerEventOverlay = {
+  kind: 'lambda-rest-v1';
+  principalId?: string;
+  context?: Record<string, unknown>;
+} | {
+  kind: 'lambda-http-v2';
+  principalId?: string;
+  context?: Record<string, unknown>;
+} | {
+  kind: 'cognito-rest-v1';
+  claims: Record<string, unknown>;
+} | {
+  kind: 'jwt-http-v2';
+  claims: Record<string, unknown>;
+  scopes?: string[];
+};
+declare function applyAuthorizerOverlay(event: Record<string, unknown>, overlay: AuthorizerEventOverlay): Record<string, unknown>;
+//#endregion
+//#region src/local/websocket-route-discovery.d.ts
+interface DiscoveredWebSocketApi {
+  apiLogicalId: string;
+  apiStackName: string;
+  declaredAt: string;
+  apiCdkPath?: string;
+  routeSelectionExpression: string;
+  stage: string;
+  routes: WebSocketRouteEntry[];
+  unsupported?: {
+    reason: string;
+  };
+}
+interface WebSocketRouteEntry {
+  routeKey: string;
+  targetLambdaLogicalId: string;
+  lambdaStackName: string;
+  declaredAt: string;
+}
+declare function discoverWebSocketApis(stacks: readonly StackInfo[]): {
+  apis: DiscoveredWebSocketApi[];
+  errors: string[];
+};
+declare function discoverWebSocketApisOrThrow(stacks: readonly StackInfo[]): DiscoveredWebSocketApi[];
+declare function parseSelectionExpressionPath(expr: string): string[];
+//#endregion
+//#region src/local/lambda-authorizer.d.ts
+interface RequestSnapshotForAuthorizer {
+  method: string;
+  headers: Record<string, string>;
+  queryStringParameters: Record<string, string>;
+  pathParameters: Record<string, string>;
+  sourceIp: string;
+  matchedPath: string;
+  stage: string;
+}
+interface AuthorizerInvocationContext {
+  pool: ContainerPool;
+  rieTimeoutMs: number;
+  methodArn: string;
+  mockAccountId: string;
+  mockApiId: string;
+}
+declare function buildMethodArn(opts: {
+  apiId: string;
+  accountId: string;
+  region?: string;
+  stage: string;
+  method: string;
+  path: string;
+}): string;
+declare function invokeTokenAuthorizer(authorizer: LambdaTokenAuthorizer, request: RequestSnapshotForAuthorizer, ctx: AuthorizerInvocationContext): Promise<CachedAuthorizerResult & {
+  identityHash: string | undefined;
+}>;
+declare function invokeRequestAuthorizer(authorizer: LambdaRequestAuthorizer, request: RequestSnapshotForAuthorizer, ctx: AuthorizerInvocationContext): Promise<CachedAuthorizerResult & {
+  identityHash: string | undefined;
+}>;
+declare function computeRequestIdentityHash(authorizer: LambdaRequestAuthorizer, request: RequestSnapshotForAuthorizer): {
+  identityHash: string;
+  missing: boolean;
+};
+declare function evaluateCachedLambdaPolicy(cached: CachedAuthorizerResult, methodArn: string): CachedAuthorizerResult;
+//#endregion
+//#region src/local/stage-resolver.d.ts
+interface ResolvedStage {
+  stageLogicalId: string;
+  stageName: string;
+  apiVersion: 'v1' | 'v2';
+  variables: Record<string, string> | null;
+}
+declare function buildStageMap(template: CloudFormationTemplate, stageOverride?: string): Map<string, ResolvedStage>;
+declare function attachStageContext(routes: DiscoveredRoute[], stageMap: Map<string, ResolvedStage>): void;
+//#endregion
+//#region src/local/cloud-map-registry.d.ts
+interface RegisteredEndpoint {
+  ip: string;
+  port: number;
+  ownerKey: string;
+}
+interface RegistrationHandle {
+  readonly fqdn: string;
+  readonly ownerKey: string;
+}
+interface RegistryListing {
+  namespace: string;
+  discoveryName: string;
+  endpoints: ReadonlyArray<RegisteredEndpoint>;
+  isAlias: boolean;
+}
+declare class CloudMapRegistry {
+  private readonly byFqdn;
+  private readonly aliasIndex;
+  register(namespace: string, discoveryName: string, endpoint: RegisteredEndpoint): RegistrationHandle;
+  registerAlias(alias: string, targetFqdn: string): void;
+  unregister(handle: RegistrationHandle): boolean;
+  unregisterByOwner(ownerKeyPrefix: string): number;
+  lookup(namespace: string, discoveryName: string): ReadonlyArray<RegisteredEndpoint> | undefined;
+  lookupAlias(alias: string): ReadonlyArray<RegisteredEndpoint> | undefined;
+  buildAddHostFlags(excludeOwnerKeyPrefix?: string): string[];
+  list(): ReadonlyArray<RegistryListing>;
+  isEmpty(): boolean;
+}
+//#endregion
+//#region src/local/runtime-image.d.ts
+declare function resolveRuntimeImage(runtime: string): string;
+declare function resolveRuntimeFileExtension(runtime: string): string;
+declare function resolveRuntimeCodeMountPath(runtime: string): string;
+//#endregion
+//#region src/local/websocket-event.d.ts
+interface WebSocketHandshakeSnapshot {
+  headers: Record<string, string[]>;
+  rawQueryString: string;
+  queryStringParameters?: Record<string, string>;
+  multiValueQueryStringParameters?: Record<string, string[]>;
+  sourceIp?: string;
+  userAgent?: string;
+}
+interface WebSocketRequestContextBase {
+  routeKey: string;
+  eventType: 'CONNECT' | 'MESSAGE' | 'DISCONNECT';
+  connectionId: string;
+  extendedRequestId: string;
+  requestTime: string;
+  requestTimeEpoch: number;
+  messageDirection: 'IN';
+  stage: string;
+  connectedAt: number;
+  requestId: string;
+  domainName: string;
+  apiId: string;
+  authorizer: null;
+  identity: {
+    accountId: string;
+    sourceIp: string;
+    userAgent: string;
+  };
+}
+interface WebSocketLambdaEvent {
+  headers?: Record<string, string>;
+  multiValueHeaders?: Record<string, string[]>;
+  queryStringParameters?: Record<string, string> | null;
+  multiValueQueryStringParameters?: Record<string, string[]> | null;
+  requestContext: WebSocketRequestContextBase & Record<string, unknown>;
+  isBase64Encoded: boolean;
+  body: string;
+}
+declare function buildConnectEvent(opts: {
+  connectionId: string;
+  connectedAt: number;
+  stage: string;
+  snapshot: WebSocketHandshakeSnapshot;
+}): WebSocketLambdaEvent;
+declare function buildMessageEvent(opts: {
+  connectionId: string;
+  connectedAt: number;
+  stage: string;
+  snapshot: WebSocketHandshakeSnapshot;
+  routeKey: string;
+  body: string;
+  isBase64Encoded: boolean;
+}): WebSocketLambdaEvent;
+declare function buildDisconnectEvent(opts: {
+  connectionId: string;
+  connectedAt: number;
+  stage: string;
+  snapshot: WebSocketHandshakeSnapshot;
+  disconnectStatusCode?: number;
+  disconnectReason?: string;
+}): WebSocketLambdaEvent;
+//#endregion
+//#region src/local/websocket-mgmt-api.d.ts
+interface ConnectionRegistryEntry {
+  connectionId: string;
+  socket: WebSocket;
+  connectedAt: number;
+  apiLogicalId: string;
+  stage: string;
+}
+declare class ConnectionRegistry {
+  private readonly entries;
+  register(entry: ConnectionRegistryEntry): void;
+  unregister(connectionId: string): ConnectionRegistryEntry | undefined;
+  get(connectionId: string): ConnectionRegistryEntry | undefined;
+  size(): number;
+  list(): ConnectionRegistryEntry[];
+  clear(): void;
+}
+declare function parseConnectionsPath(url: string): {
+  connectionId: string;
+} | null;
+declare function buildMgmtEndpointEnvUrl(host: string, port: number, stage: string): string;
+declare function handleConnectionsRequest(opts: {
+  req: IncomingMessage;
+  res: ServerResponse;
+  registry: ConnectionRegistry;
+}): Promise<void>;
+//#endregion
+//#region src/local/websocket-body.d.ts
+declare function bufferToBody(raw: Buffer | ArrayBuffer | Buffer[], isBinary: boolean): {
+  body: string;
+  isBase64Encoded: boolean;
+};
+//#endregion
+//#region src/local/docker-version.d.ts
+declare const HOST_GATEWAY_MIN_VERSION: ParsedDockerVersion;
+interface ParsedDockerVersion {
+  major: number;
+  minor: number;
+  patch: number;
+}
+interface HostGatewayProbeResult {
+  rawVersion: string;
+  parsed: ParsedDockerVersion | null;
+  supported: boolean;
+}
+declare function probeHostGatewaySupport(): Promise<HostGatewayProbeResult>;
+//#endregion
+//#region src/local/api-server-grouping.d.ts
+interface ApiServerGroup {
+  readonly serverKey: string;
+  readonly displayName: string;
+  readonly kind: 'rest-v1' | 'http-api' | 'function-url' | 'websocket';
+  readonly identifier: string;
+  readonly routes: readonly RouteWithAuth[];
+}
+declare function groupRoutesByServer(routes: readonly RouteWithAuth[]): ApiServerGroup[];
+declare function filterRoutesByApiIdentifier(routes: readonly RouteWithAuth[], identifier: string): RouteWithAuth[];
+declare function filterRoutesByApiIdentifiers(routes: readonly RouteWithAuth[], identifiers: readonly string[]): RouteWithAuth[];
+declare function availableApiIdentifiers(routes: readonly RouteWithAuth[]): string[];
+//#endregion
+//#region src/local/layer-arn-materializer.d.ts
+interface MaterializeLayerOptions {
+  roleArn?: string;
+  lambdaClientFactory?: (region: string, credentials?: AwsCredentials) => LambdaSendClient;
+  stsClientFactory?: (region: string) => StsSendClient;
+  fetchZip?: (presignedUrl: string) => Promise<Uint8Array>;
+}
+interface AwsCredentials {
+  accessKeyId: string;
+  secretAccessKey: string;
+  sessionToken?: string;
+}
+interface LambdaSendClient {
+  send(command: any): Promise<{
+    Content?: {
+      Location?: string;
+    };
+  }>;
+  destroy?: () => void;
+}
+interface StsSendClient {
+  send(command: any): Promise<{
+    Credentials?: {
+      AccessKeyId?: string;
+      SecretAccessKey?: string;
+      SessionToken?: string;
+    };
+  }>;
+  destroy?: () => void;
+}
+declare function materializeLayerFromArn(layer: ResolvedArnLambdaLayer, options?: MaterializeLayerOptions): Promise<string>;
+//#endregion
+//#region src/local/cloud-map-resolver.d.ts
+interface ResolvedCloudMapNamespace {
+  logicalId: string;
+  name: string;
+}
+interface ResolvedCloudMapService {
+  logicalId: string;
+  namespaceLogicalId: string;
+  namespaceName: string;
+  name: string;
+  dnsRecords: ReadonlyArray<{
+    type: 'A' | 'SRV';
+    ttlSeconds: number;
+  }>;
+}
+interface CloudMapIndex {
+  namespacesByLogicalId: Map<string, ResolvedCloudMapNamespace>;
+  namespacesByName: Map<string, ResolvedCloudMapNamespace>;
+  servicesByLogicalId: Map<string, ResolvedCloudMapService>;
+  warnings: string[];
+}
+declare function buildCloudMapIndex(stack: StackInfo): CloudMapIndex;
+//#endregion
+//#region src/local/agentcore-code-build.d.ts
+declare const SUPPORTED_CODE_RUNTIMES: string[];
+interface BuildAgentCoreCodeImageOptions {
+  sourceDir: string;
+  runtime: string;
+  entryPoint: string[];
+  architecture: 'x86_64' | 'arm64';
+  noBuild?: boolean;
+}
+declare function buildAgentCoreCodeImage(options: BuildAgentCoreCodeImageOptions): Promise<string>;
+declare function renderCodeDockerfile(base: string, entryPoint: string[], isNode: boolean): string;
+declare function toCmdArgv(entryPoint: string[], isNode: boolean): string[];
+declare function computeCodeImageTag(sourceDir: string, runtime: string, entryPoint: string[], dockerfile: string): string;
+//#endregion
+//#region src/types/assets.d.ts
+interface DockerImageAssetSource {
+  directory?: string;
+  executable?: string[];
+  dockerFile?: string;
+  dockerBuildTarget?: string;
+  dockerBuildArgs?: Record<string, string>;
+  dockerBuildContexts?: Record<string, string>;
+  dockerBuildSsh?: string;
+  dockerBuildSecrets?: Record<string, string>;
+  networkMode?: string;
+  platform?: string;
+  dockerOutputs?: string[];
+  cacheFrom?: DockerCacheOption[];
+  cacheTo?: DockerCacheOption;
+  cacheDisabled?: boolean;
+}
+interface DockerCacheOption {
+  type: string;
+  params?: Record<string, string>;
+}
+//#endregion
+//#region src/local/docker-image-builder.d.ts
+interface BuildContainerImageOptions {
+  architecture: 'x86_64' | 'arm64';
+  noBuild?: boolean;
+}
+declare function buildContainerImage(asset: {
+  source: DockerImageAssetSource;
+}, cdkOutDir: string, options: BuildContainerImageOptions): Promise<string>;
+declare function architectureToPlatform(architecture: 'x86_64' | 'arm64'): string;
+//#endregion
+//#region src/local/file-watcher.d.ts
+interface FileWatcher {
+  close(): Promise<void>;
+}
+interface FileWatcherOptions {
+  paths: readonly string[];
+  onChange: () => void;
+  debounceMs?: number;
+  ignoreInitial?: boolean;
+  ignored?: (path: string) => boolean;
+  shouldTrigger?: (path: string) => boolean;
+}
+declare function createFileWatcher(options: FileWatcherOptions): FileWatcher;
+//#endregion
+export { HttpRequestSnapshot as $, LocalStateProvider as $n, discoverRoutes as $t, WebSocketLambdaEvent as A, AgentCoreJwtAuthorizer as An, defaultCredentialsLoader as At, attachStageContext as B, getEmbedConfig as Bn, CachedAuthorizerResult as Bt, bufferToBody as C, InvokeAgentCoreOptions as Cn, resolveApiTargetSubset as Ct, handleConnectionsRequest as D, AGENTCORE_MCP_PROTOCOL as Dn, readMtlsMaterialsFromDisk as Dt, buildMgmtEndpointEnvUrl as E, AGENTCORE_HTTP_PROTOCOL as En, StartedApiServer as Et, resolveRuntimeFileExtension as F, derivePseudoParametersFromRegion as Fn, createJwksCache as Ft, invokeRequestAuthorizer as G, LocalStateSourceError as Gn, CorsConfig as Gt, buildMethodArn as H, setEmbedConfig as Hn, AuthorizerInfo as Ht, resolveRuntimeImage as I, substituteImagePlaceholders as In, verifyCognitoJwt as It, WebSocketRouteEntry as J, isCfnFlagPresent as Jn, buildCorsConfigFromCloudFrontChain as Jt, invokeTokenAuthorizer as K, LocalStateSourceOptions as Kn, applyCorsResponseHeaders as Kt, CloudMapRegistry as L, tryResolveImageFnJoin as Ln, verifyJwtAuthorizer as Lt, buildDisconnectEvent as M, ResolvedAgentCoreRuntime as Mn, JwksCache as Mt, buildMessageEvent as N, resolveAgentCoreTarget as Nn, buildCognitoJwksUrl as Nt, parseConnectionsPath as O, AGENTCORE_RUNTIME_TYPE as On, startApiServer as Ot, resolveRuntimeCodeMountPath as P, ImageResolutionContext as Pn, buildJwksUrlFromIssuer as Pt, AuthorizerEventOverlay as Q, resolveCfnStackName as Qn, RestV1IntegrationConfig as Qt, RegistrationHandle as R, StackInfo as Rn, verifyJwtViaDiscovery as Rt, probeHostGatewaySupport as S, AgentCoreInvokeResult as Sn, createWatchPredicates as St, ConnectionRegistryEntry as T, waitForAgentCorePing as Tn, ServerState as Tt, computeRequestIdentityHash as U, ExtraStateProviders as Un, RouteWithAuth as Ut, buildStageMap as V, resetEmbedConfig as Vn, createAuthorizerCache as Vt, evaluateCachedLambdaPolicy as W, LocalStateProviderFactory as Wn, attachAuthorizers as Wt, discoverWebSocketApisOrThrow as X, resolveCfnFallbackRegion as Xn, matchPreflight as Xt, discoverWebSocketApis as Y, rejectExplicitCfnStackWithMultipleStacks as Yn, isFunctionUrlOacFronted as Yt, parseSelectionExpressionPath as Z, resolveCfnRegion as Zn, DiscoveredRoute as Zt, availableApiIdentifiers as _, McpInvokeResult as _n, EcsTaskResolutionError as _t, architectureToPlatform as a, VtlEvaluationError as an, CrossStackResolver as ar, matchRoute as at, groupRoutesByServer as b, parseSseForJsonRpc as bn, WatchPredicates as bt, SUPPORTED_CODE_RUNTIMES as c, EnvOverrideFile as cn, SubstitutionContext as cr, translateLambdaResponse as ct, renderCodeDockerfile as d, InvokeAgentCoreWsOptions as dn, substituteEnvVarsFromState as dr, resolveSelectionExpression as dt, IntegrationResponseEntry as en, LocalStateRecord as er, MatchedRouteContext as et, toCmdArgv as f, invokeAgentCoreWs as fn, substituteEnvVarsFromStateAsync as fr, resolveServiceIntegrationParameters as ft, ApiServerGroup as g, McpInvokeOptions as gn, LocalInvokeBuildError as gt, materializeLayerFromArn as h, MCP_PROTOCOL_VERSION as hn, pickRefLogicalId as ht, BuildContainerImageOptions as i, tryParseStatus as in, resolveSsmParameters as ir, RouteMatchResult as it, buildConnectEvent as j, AgentCoreResolutionError as jn, DiscoveryJwtAuthorizer as jt, WebSocketHandshakeSnapshot as k, AgentCoreCodeArtifact as kn, CredentialsLoader as kt, buildAgentCoreCodeImage as l, resolveEnvVars as ln, substituteAgainstState as lr, RequestParameterContext as lt, buildCloudMapIndex as m, MCP_PATH as mn, resolveLambdaArnIntrinsic as mt, FileWatcherOptions as n, pickResponseTemplate as nn, SsmParameterRef as nr, buildHttpApiV2Event as nt, buildContainerImage as o, CdkWatchConfig as on, PseudoParameters as or, getContainerNetworkIp as ot, CloudMapIndex as p, MCP_CONTAINER_PORT as pn, CloudFormationTemplate as pr, LambdaArnResolveOutcome as pt, DiscoveredWebSocketApi as q, createLocalStateProvider as qn, buildCorsConfigByApiId as qt, createFileWatcher as r, selectIntegrationResponse as rn, collectSsmParameterRefs as rr, buildRestV1Event as rt, BuildAgentCoreCodeImageOptions as s, resolveWatchConfig as sn, StateEnvSubstitutionAudit as sr, TranslatedHttpResponse as st, FileWatcher as t, evaluateResponseParameters as tn, ResolvedSsmParameters as tr, applyAuthorizerOverlay as tt, computeCodeImageTag as u, AgentCoreWsResult as un, substituteAgainstStateAsync as ur, ResolveParametersOutcome as ut, filterRoutesByApiIdentifier as v, McpJsonRpcRequest as vn, ApiTargetSubset as vt, ConnectionRegistry as w, invokeAgentCore as wn, MtlsServerConfig as wt, HOST_GATEWAY_MIN_VERSION as x, AGENTCORE_SESSION_ID_HEADER as xn, createLocalStartApiCommand as xt, filterRoutesByApiIdentifiers as y, mcpInvokeOnce as yn, CreateLocalStartApiCommandOptions as yt, ResolvedStage as z, CdkLocalEmbedConfig as zn, AuthorizerCache as zt };
+//# sourceMappingURL=internal-CPdFiC6i.d.ts.map