cdk-local 0.46.0 → 0.48.0

package/dist/error-handler-BfysjFFj.d.ts

@@ -0,0 +1,696 @@
+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
+export { InvokeAgentCoreWsOptions as $, substituteAgainstStateAsync as $t, RouteWithAuth as A, resetEmbedConfig as At, discoverRoutes as B, resolveCfnRegion as Bt, verifyJwtViaDiscovery as C, derivePseudoParametersFromRegion as Ct, AuthorizerInfo as D, StackInfo as Dt, createAuthorizerCache as E, ResolvedArnLambdaLayer as Et, buildCorsConfigFromCloudFrontChain as F, LocalStateSourceOptions as Ft, tryParseStatus as G, SsmParameterRef as Gt, evaluateResponseParameters as H, LocalStateProvider as Ht, isFunctionUrlOacFronted as I, createLocalStateProvider as It, CdkWatchConfig as J, CrossStackResolver as Jt, VtlEvaluationError as K, collectSsmParameterRefs as Kt, matchPreflight as L, isCfnFlagPresent as Lt, CorsConfig as M, ExtraStateProviders as Mt, applyCorsResponseHeaders as N, LocalStateProviderFactory as Nt, LambdaRequestAuthorizer as O, CdkLocalEmbedConfig as Ot, buildCorsConfigByApiId as P, LocalStateSourceError as Pt, AgentCoreWsResult as Q, substituteAgainstState as Qt, DiscoveredRoute as R, rejectExplicitCfnStackWithMultipleStacks as Rt, verifyJwtAuthorizer as S, ImageResolutionContext as St, CachedAuthorizerResult as T, tryResolveImageFnJoin as Tt, pickResponseTemplate as U, LocalStateRecord as Ut, IntegrationResponseEntry as V, resolveCfnStackName as Vt, selectIntegrationResponse as W, ResolvedSsmParameters as Wt, EnvOverrideFile as X, StateEnvSubstitutionAudit as Xt, resolveWatchConfig as Y, PseudoParameters as Yt, resolveEnvVars as Z, SubstitutionContext as Zt, JwksCache as _, AgentCoreCodeArtifact as _t, WatchPredicates as a, McpInvokeResult as at, createJwksCache as b, ResolvedAgentCoreRuntime as bt, resolveApiTargetSubset as c, parseSseForJsonRpc as ct, StartedApiServer as d, InvokeAgentCoreOptions as dt, substituteEnvVarsFromState as en, invokeAgentCoreWs as et, readMtlsMaterialsFromDisk as f, invokeAgentCore as ft, DiscoveryJwtAuthorizer as g, AGENTCORE_RUNTIME_TYPE as gt, defaultCredentialsLoader as h, AGENTCORE_MCP_PROTOCOL as ht, CreateLocalStartApiCommandOptions as i, McpInvokeOptions as it, attachAuthorizers as j, setEmbedConfig as jt, LambdaTokenAuthorizer as k, getEmbedConfig as kt, MtlsServerConfig as l, AGENTCORE_SESSION_ID_HEADER as lt, CredentialsLoader as m, AGENTCORE_HTTP_PROTOCOL as mt, EcsTaskResolutionError as n, CloudFormationTemplate as nn, MCP_PATH as nt, createLocalStartApiCommand as o, McpJsonRpcRequest as ot, startApiServer as p, waitForAgentCorePing as pt, ContainerPool as q, resolveSsmParameters as qt, ApiTargetSubset as r, MCP_PROTOCOL_VERSION as rt, createWatchPredicates as s, mcpInvokeOnce as st, LocalInvokeBuildError as t, substituteEnvVarsFromStateAsync as tn, MCP_CONTAINER_PORT as tt, ServerState as u, AgentCoreInvokeResult as ut, buildCognitoJwksUrl as v, AgentCoreJwtAuthorizer as vt, AuthorizerCache as w, substituteImagePlaceholders as wt, verifyCognitoJwt as x, resolveAgentCoreTarget as xt, buildJwksUrlFromIssuer as y, AgentCoreResolutionError as yt, RestV1IntegrationConfig as z, resolveCfnFallbackRegion as zt };
+//# sourceMappingURL=error-handler-BfysjFFj.d.ts.map