import { $ as serviceStrategy, $t as RouteWithAuth, A as addListSpecificOptions, An as InvokeAgentCoreWsOptions, At as TargetEntry, B as normalizeKvsFileKeys, Bt as ResolvedEcsTask, C as StudioEventBus, Cn as isProxyEnvConfigured, Ct as FrontDoorForwardTarget, D as StudioTargetKind, Dn as AgentCoreWsBridgeHandle, Dt as DEFAULT_SHADOW_READY_TIMEOUT_MS, E as StudioServeEvent, Et as resolveAlbFrontDoor, Fn as formatStateRemedy, Ft as LocalInvokeBuildError, G as addAlbSpecificOptions, H as parseOriginOverrides, Hn as StackInfo, In as substituteImagePlaceholders, J as parseLbPortOverrides, Jt as AuthorizerInfo, K as albStrategy, Kt as createWatchPredicates, L as LocalStartCloudFrontError, Ln as tryResolveImageFnJoin, Lt as addRunTaskSpecificOptions, Mn as invokeAgentCoreWs, Nn as ImageResolutionContext, On as AgentCoreWsResult, Ot as SOFT_RELOAD_COMPLETION_LOG_SUFFIX, P as addStartAgentCoreSpecificOptions, Pn as derivePseudoParametersFromRegion, Pt as CdkLocalError, Qt as LambdaTokenAuthorizer, R as addStartCloudFrontSpecificOptions, S as createStudioDispatcher, Sn as buildProxyClientConfig, St as runEcsServiceEmulator, T as StudioLogEvent, Tn as addInvokeAgentCoreSpecificOptions, Tt as isApplicationLoadBalancer, U as resolveCloudFrontTarget, Ut as WatchPredicates, V as parseKvsFileOverrides, Vn as ResolvedArnLambdaLayer, Vt as ApiTargetSubset, Wt as addStartApiSpecificOptions, Xt as JwtAuthorizer, Y as resolveAlbTarget, Yt as CognitoUserPoolAuthorizer, Z as addStartServiceSpecificOptions, Zt as LambdaRequestAuthorizer, _ as startStudioProxy, _n as CdkWatchConfig, _r as CloudFormationTemplate, _t as ecsClusterOption, a as coerceServeRequest, an as discoverWebSocketApisOrThrow, at as PlannedEcsForwardTarget, b as StudioRunRequest, bn as resolveProfileCredentials, bt as resolveEcsAssumeRoleOption, c as resolveServeBaseUrl, cn as webSocketApiMatchesIdentifier, ct as PlannedForwardTarget, d as StudioServeRequest, dn as discoverRoutes, dt as PlannedRedirectAction, en as attachAuthorizers, et as EcsServiceEmulatorOptions, f as StudioServeState, fn as IntegrationResponseEntry, ft as ServiceBoot, g as StudioProxyConfig, gn as tryParseStatus, gt as buildEcsImageResolutionContext, h as RunningStudioProxy, hn as selectIntegrationResponse, ht as addImageOverrideOptions, i as coerceRunRequest, in as discoverWebSocketApis, it as PlannedAction, jn as bridgeAgentCoreWs, jt as TargetListing, kn as BridgeAgentCoreWsOptions, kt as setShadowReadyTimeoutMs, l as StudioServeManager, ln as DiscoveredRoute, lt as PlannedFrontDoorListener, m as createStudioServeManager, mn as pickResponseTemplate, mt as addEcsAssumeRoleOptions, n as StudioServeRequestPayload, nn as WebSocketRouteEntry, nt as FrontDoorPlan, o as coerceStopRequest, on as filterWebSocketApisByIdentifiers, ot as PlannedFixedResponseAction, p as StudioStopRequest, pn as evaluateResponseParameters, pt as addCommonEcsServiceOptions, qt as resolveApiTargetSubset, r as addStudioSpecificOptions, rn as availableWebSocketApiIdentifiers, rt as MAX_TASKS_SUBNET_RANGE_CAP, sn as parseSelectionExpressionPath, st as PlannedForwardAction, tn as DiscoveredWebSocketApi, tt as EmulatorStrategy, u as StudioServeManagerConfig, un as RestV1IntegrationConfig, ut as PlannedLambdaForwardTarget, v as StudioDispatchConfig, vn as resolveWatchConfig, vr as TemplateResource, vt as parseMaxTasks, w as StudioInvocationEvent, wt as ResolvedListenerAction, x as StudioRunResult, xn as AwsProxyClientConfig, xt as resolveSharedSidecarCredentials, y as StudioDispatcher, yn as buildStsClientConfig, yt as parseRestartPolicy, zn as addInvokeSpecificOptions, zt as EcsTaskResolutionError } from "./local-studio-9bZLFQqv.js";
import { IncomingHttpHeaders, IncomingMessage, Server, ServerResponse } from "node:http";
import { WebSocket } from "ws";
import * as vm from "node:vm";
import "@aws-sdk/signature-v4a";
//#region src/local/file-watcher.d.ts
interface FileWatcher {
  close(): Promise<void>;
}
interface FileWatcherOptions {
  paths: readonly string[];
  onChange: (changedPaths: readonly string[]) => void;
  debounceMs?: number;
  ignoreInitial?: boolean;
  ignored?: (path: string) => boolean;
  shouldTrigger?: (path: string) => boolean;
}
declare function createFileWatcher(options: FileWatcherOptions): FileWatcher;
//#endregion
//#region src/local/source-change-classifier.d.ts
interface ReloadAssetContext {
  oldAssetHash?: string;
  newAssetHash: string;
  newAssetSourceDir: string;
  dockerFile: string;
}
type ReloadVerdict = {
  kind: 'rebuild';
  reason: string;
} | {
  kind: 'soft-reload';
  reason: string;
  newAssetSourceDir: string;
};
declare function classifySourceChange(changedPaths: readonly string[], ctx: ReloadAssetContext | undefined): ReloadVerdict;
//#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";
declare const AGENTCORE_A2A_PROTOCOL = "A2A";
declare const AGENTCORE_AGUI_PROTOCOL = "AGUI";
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[];
  allowedScopes?: string[];
  customClaims?: AgentCoreCustomClaim[];
}
interface AgentCoreCustomClaim {
  name: string;
  valueType: 'STRING' | 'STRING_ARRAY';
  operator: 'EQUALS' | 'CONTAINS' | 'CONTAINS_ANY';
  value: string | string[];
}
interface AgentCoreCodeArtifact {
  runtime: string;
  entryPoint: string[];
  codeAssetHash: string;
  s3Source?: {
    bucket?: string;
    bucketIntrinsic?: unknown;
    key: string;
    versionId?: string;
  };
}
declare class AgentCoreResolutionError extends Error {
  constructor(message: string);
}
declare function resolveAgentCoreTarget(target: string, stacks: StackInfo[], imageContext?: ImageResolutionContext): ResolvedAgentCoreRuntime;
declare function pickAgentCoreCandidateStack(target: string, stacks: StackInfo[]): StackInfo | undefined;
//#endregion
//#region src/local/agentcore-sigv4-sign.d.ts
declare const AGENTCORE_SIGV4_SERVICE = "bedrock-agentcore";
interface SigV4Credentials {
  accessKeyId: string;
  secretAccessKey: string;
  sessionToken?: string;
}
interface SignAgentCoreInvocationOptions {
  credentials: SigV4Credentials;
  region: string;
  host: string;
  port: number;
  path: string;
  body: string | Buffer;
  sessionId: string;
  method?: string;
  now?: () => number;
}
interface SignedAgentCoreHeaders {
  authorization: string;
  amzDate: string;
  amzContentSha256: string;
  amzSecurityToken?: string;
}
declare function signAgentCoreInvocation(opts: SignAgentCoreInvocationOptions): Promise<SignedAgentCoreHeaders>;
//#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>;
declare function waitForAgentCoreHttpReady(host: string, port: number, path: string, timeoutMs?: number): Promise<void>;
interface InvokeAgentCoreOptions {
  sessionId: string;
  timeoutMs: number;
  authorization?: string;
  additionalHeaders?: Record<string, 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-a2a-client.d.ts
declare const A2A_CONTAINER_PORT = 9000;
declare const A2A_PATH = "/";
interface A2aJsonRpcRequest {
  method: string;
  params?: unknown;
}
interface A2aInvokeResult {
  ok: boolean;
  raw: string;
}
interface A2aInvokeOptions {
  readyTimeoutMs?: number;
  requestTimeoutMs?: number;
  fetchImpl?: typeof fetch;
}
declare function a2aInvokeOnce(host: string, port: number, request: A2aJsonRpcRequest, options?: A2aInvokeOptions): Promise<A2aInvokeResult>;
//#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/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/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/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-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;
}
type WarnedAt = Map<string, number>;
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;
  warnedAt?: WarnedAt;
}): Promise<CachedAuthorizerResult & {
  identityHash: string | undefined;
  ttlSeconds: number;
}>;
declare function verifyJwtAuthorizer(authorizer: JwtAuthorizer, authorizationHeader: string | undefined, jwksCache: JwksCache, opts?: {
  now?: () => number;
  warnedAt?: WarnedAt;
}): Promise<CachedAuthorizerResult & {
  identityHash: string | undefined;
  ttlSeconds: number;
}>;
interface DiscoveryJwtAuthorizer {
  discoveryUrl: string;
  allowedAudience?: readonly string[];
  allowedClients?: readonly string[];
  allowedScopes?: readonly string[];
  customClaims?: readonly JwtCustomClaim[];
}
interface JwtCustomClaim {
  name: string;
  valueType: 'STRING' | 'STRING_ARRAY';
  operator: 'EQUALS' | 'CONTAINS' | 'CONTAINS_ANY';
  value: string | string[];
}
declare function verifyJwtViaDiscovery(authorizer: DiscoveryJwtAuthorizer, authorizationHeader: string | undefined, jwksCache: JwksCache, opts?: {
  now?: () => number;
  warnedAt?: WarnedAt;
  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;
  jwksWarnedAt?: WarnedAt;
  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/local/ecs-service-resolver.d.ts
interface ResolvedServiceConnect {
  namespaceName: string;
  services: ReadonlyArray<{
    portName: string;
    containerPort: number;
    discoveryName: string;
    clientAliases: ReadonlyArray<{
      dnsName?: string;
      port: number;
    }>;
  }>;
}
interface ResolvedServiceRegistry {
  cloudMapServiceLogicalId: string;
  containerName?: string;
  containerPort?: number;
}
interface ResolvedEcsService {
  stack: StackInfo;
  serviceLogicalId: string;
  resource: TemplateResource;
  serviceName: string;
  serviceDisplayName: string;
  desiredCount: number;
  healthCheckGracePeriodSeconds: number;
  task: ResolvedEcsTask;
  serviceConnect?: ResolvedServiceConnect;
  serviceRegistries: ReadonlyArray<ResolvedServiceRegistry>;
  warnings: string[];
}
//#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/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/cloudfront-kvs.d.ts
interface KvsDataSource {
  readonly label: string;
  readonly kvsId?: string;
  getValue(key: string): Promise<string | undefined>;
}
interface CloudFrontKvsHandle {
  get(key: string, options?: {
    format?: 'string' | 'json';
  }): Promise<unknown>;
  exists(key: string): Promise<boolean>;
  meta(): Promise<never>;
  count(): Promise<never>;
}
interface CloudFrontModule {
  kvs(kvsId?: string): CloudFrontKvsHandle;
}
declare function createCloudFrontModule(sources: readonly KvsDataSource[]): CloudFrontModule;
declare function createUnboundCloudFrontModule(functionLogicalId: string): CloudFrontModule;
declare function createLocalFileKvsDataSource(args: {
  id: string;
  filePath: string;
}): KvsDataSource;
//#endregion
//#region src/local/cloudfront-function-runtime.d.ts
interface CfValue {
  value: string;
  multiValue?: Array<{
    value: string;
  }>;
}
interface CfRequest {
  method: string;
  uri: string;
  querystring: Record<string, CfValue>;
  headers: Record<string, CfValue>;
  cookies: Record<string, CfValue>;
}
interface CfResponse {
  statusCode: number;
  statusDescription?: string;
  headers: Record<string, CfValue>;
  cookies?: Record<string, CfValue>;
  body?: string | {
    encoding?: 'text' | 'base64';
    data?: string;
  };
}
interface CfViewerRequestEvent {
  version: '1.0';
  context: {
    distributionDomainName: string;
    distributionId: string;
    eventType: string;
    requestId: string;
  };
  viewer: {
    ip: string;
  };
  request: CfRequest;
}
interface CfViewerResponseEvent extends CfViewerRequestEvent {
  response: CfResponse;
}
interface CloudFrontKvsAssociation {
  arnValue: unknown;
  kvsLogicalId?: string;
}
interface CompiledCloudFrontFunction {
  logicalId: string;
  runtime: string;
  script: vm.Script;
  cloudfrontBindingName?: string;
  kvsAssociations?: CloudFrontKvsAssociation[];
  cloudfrontModule?: CloudFrontModule;
}
declare function stripCloudFrontImport(code: string): {
  code: string;
  bindingName?: string;
};
declare function compileCloudFrontFunction(logicalId: string, code: string, runtime: string): CompiledCloudFrontFunction;
type ViewerRequestOutcome = {
  kind: 'continue';
  request: CfRequest;
} | {
  kind: 'response';
  response: CfResponse;
};
declare function runViewerRequest(fn: CompiledCloudFrontFunction, event: CfViewerRequestEvent): Promise<ViewerRequestOutcome>;
declare function runViewerResponse(fn: CompiledCloudFrontFunction, event: CfViewerResponseEvent): Promise<CfResponse>;
//#endregion
//#region src/local/cloudfront-static-origin.d.ts
interface ResolvedCustomErrorResponse {
  errorCode: number;
  responsePagePath?: string;
  responseCode?: number;
}
interface StaticOriginResult {
  statusCode: number;
  headers: Record<string, string>;
  body: Buffer;
}
declare function serveFromStaticOrigin(input: {
  localDirs: readonly string[];
  uri: string;
  defaultRootObject?: string;
  customErrorResponses?: readonly ResolvedCustomErrorResponse[];
}): StaticOriginResult;
interface ErrorResponseCandidate {
  errorKey: string;
  responseCode: number;
}
declare function resolveErrorResponseCandidates(customErrorResponses?: readonly ResolvedCustomErrorResponse[]): ErrorResponseCandidate[];
//#endregion
//#region src/local/cloudfront-resolver.d.ts
interface ResolvedCloudFrontFunction extends CompiledCloudFrontFunction {}
interface ResolvedLambdaEdgeAssoc {
  functionLogicalId: string;
  includeBody: boolean;
}
interface ResolvedLambdaEdge {
  viewerRequest?: ResolvedLambdaEdgeAssoc;
  originRequest?: ResolvedLambdaEdgeAssoc;
  originResponse?: ResolvedLambdaEdgeAssoc;
  viewerResponse?: ResolvedLambdaEdgeAssoc;
}
interface ResolvedBehavior {
  pathPattern?: string;
  targetOriginId: string;
  viewerProtocolPolicy?: string;
  viewerRequest?: ResolvedCloudFrontFunction;
  viewerResponse?: ResolvedCloudFrontFunction;
  lambdaEdge?: ResolvedLambdaEdge;
  cors?: CorsConfig;
}
type ResolvedOrigin = {
  kind: 's3';
  originId: string;
  localDirs: string[];
} | {
  kind: 's3-unresolved';
  originId: string;
  bucketLogicalId?: string;
  bucketName?: string;
  deployedConfigOnly?: boolean;
} | {
  kind: 's3-deployed';
  originId: string;
  bucketName: string;
} | {
  kind: 'lambda-url';
  originId: string;
  functionLogicalId: string;
  functionUrlLogicalId: string;
} | {
  kind: 'custom';
  originId: string;
  domainName: string;
};
interface ResolvedDistribution {
  logicalId: string;
  stackName: string;
  defaultRootObject?: string;
  behaviors: ResolvedBehavior[];
  origins: Map<string, ResolvedOrigin>;
  customErrorResponses: ResolvedCustomErrorResponse[];
}
declare const CLOUDFRONT_DISTRIBUTION_TYPE = "AWS::CloudFront::Distribution";
declare function resolveCloudFrontDistribution(args: {
  stack: StackInfo;
  logicalId: string;
  originOverrides?: Map<string, string>;
}): ResolvedDistribution;
declare function extractKvsAssociations(functionConfig: Record<string, unknown>): CloudFrontKvsAssociation[];
declare function pickKvsLogicalIdFromArn(value: unknown): string | undefined;
declare function pickLambdaEdgeFunctionLogicalId(value: unknown, template: CloudFormationTemplate): string | undefined;
declare function describeS3OriginDomain(value: unknown): {
  isS3: boolean;
  bucketName?: string;
};
declare function pickFunctionUrlLogicalIdFromOrigin(value: unknown): string | undefined;
declare function pickTargetFunctionLogicalId(value: unknown): string | undefined;
declare function isCloudFrontDistribution(resource: TemplateResource): boolean;
//#endregion
//#region src/local/cloudfront-s3-origin.d.ts
interface S3OriginCredentials {
  accessKeyId: string;
  secretAccessKey: string;
  sessionToken?: string;
}
type S3FetchResult = {
  kind: 'found';
  body: Buffer;
} | {
  kind: 'not-found';
} | {
  kind: 'denied';
} | {
  kind: 'error';
  message: string;
};
type S3ObjectFetcher = (key: string) => Promise<S3FetchResult>;
interface S3OriginReaderOptions {
  region?: string;
  credentials?: S3OriginCredentials;
  cache?: boolean;
  fetchObject?: S3ObjectFetcher;
}
interface S3OriginReader {
  (input: {
    uri: string;
    defaultRootObject?: string;
    customErrorResponses?: readonly ResolvedCustomErrorResponse[];
  }): Promise<StaticOriginResult>;
  close(): Promise<void>;
  clearCache(): void;
}
declare function createS3OriginReader(bucketName: string, options?: S3OriginReaderOptions): S3OriginReader;
declare function classifyS3Error(err: unknown): S3FetchResult;
//#endregion
//#region src/local/front-door-tls.d.ts
interface FrontDoorTlsMaterials {
  certPem: Buffer;
  keyPem: Buffer;
}
//#endregion
//#region src/local/cloudfront-server.d.ts
type LambdaUrlInvokerMap = Map<string, (event: Record<string, unknown>) => Promise<unknown>>;
interface StartedCloudFrontServer {
  url: string;
  port: number;
  scheme: 'http' | 'https';
  update(distribution: ResolvedDistribution): void;
  close(): Promise<void>;
}
interface StartCloudFrontServerOptions {
  distribution: ResolvedDistribution;
  host: string;
  port: number;
  tls?: FrontDoorTlsMaterials;
  lambdaInvokers?: LambdaUrlInvokerMap;
  edgeInvokers?: LambdaUrlInvokerMap;
  s3OriginReaders?: Map<string, S3OriginReader>;
}
declare function startCloudFrontServer(options: StartCloudFrontServerOptions): Promise<StartedCloudFrontServer>;
declare function matchBehavior(behaviors: readonly ResolvedBehavior[], uri: string): ResolvedBehavior | undefined;
//#endregion
//#region src/local/agentcore-serve-auth.d.ts
interface AgentCoreServeAuthResult {
  allow: boolean;
  status?: number;
  message?: string;
  authorization?: string;
}
type AgentCoreServeAuthCheck = (headers: IncomingHttpHeaders) => Promise<AgentCoreServeAuthResult>;
interface BuildAgentCoreServeAuthCheckOptions {
  noVerifyAuth?: boolean;
  bearerToken?: string;
  jwksCache?: JwksCache;
  warnedAt?: WarnedAt;
}
declare function buildAgentCoreServeAuthCheck(authorizer: AgentCoreJwtAuthorizer, opts?: BuildAgentCoreServeAuthCheckOptions): AgentCoreServeAuthCheck;
interface ServeInboundAuthPlan {
  authCheck?: AgentCoreServeAuthCheck;
  bridgeAuthorization?: string;
  sign: boolean;
}
declare function selectServeInboundAuth(resolved: Pick<ResolvedAgentCoreRuntime, 'jwtAuthorizer'>, options: {
  bearerToken?: string;
  verifyAuth?: boolean;
}, sigv4Active: boolean, buildAuthCheck?: typeof buildAgentCoreServeAuthCheck): ServeInboundAuthPlan;
//#endregion
//#region src/local/agentcore-http-server.d.ts
interface AgentCoreServeRoute {
  method: string;
  path: string;
}
type AgentCoreServeSignRequest = (opts: {
  method: string;
  path: string;
  body: Buffer;
  sessionId: string;
}) => Promise<Record<string, string>>;
interface AgentCoreHttpServerConfig {
  containerHost: string;
  containerPort: number;
  host?: string;
  port?: number;
  sessionId?: string;
  authorization?: string;
  routes?: AgentCoreServeRoute[];
  attachWs?: boolean;
  authCheck?: AgentCoreServeAuthCheck;
  signRequest?: AgentCoreServeSignRequest;
}
interface RunningAgentCoreHttpServer {
  httpUrl: string;
  wsUrl?: string;
  port: number;
  setContainerPort(port: number): void;
  close(): Promise<void>;
}
declare function startAgentCoreHttpServer(config: AgentCoreHttpServerConfig): Promise<RunningAgentCoreHttpServer>;
//#endregion
//#region src/local/studio-store.d.ts
interface StudioStoreOptions {
  maxInvocations?: number;
  maxLogs?: number;
  bindGraceMs?: number;
}
interface StudioHistory {
  invocations: StudioInvocationEvent[];
  logs: StudioLogEvent[];
}
interface StudioLogSearchOptions {
  target?: string;
  limit?: number;
}
interface StudioStore {
  history: () => StudioHistory;
  searchLogs: (query: string, opts?: StudioLogSearchOptions) => StudioLogEvent[];
  logsForInvocation: (id: string) => StudioLogEvent[];
  invocation: (id: string) => StudioInvocationEvent | undefined;
  dispose: () => void;
}
declare function createStudioStore(bus: StudioEventBus, options?: StudioStoreOptions): StudioStore;
//#endregion
//#region src/local/studio-server.d.ts
interface StudioTarget {
  id: string;
  qualifiedId: string;
  surface?: string;
  servable?: boolean;
  pinned?: boolean;
  pinUnresolved?: boolean;
  backingPinnedServices?: {
    id: string;
    label: string;
  }[];
  agentCoreHasWs?: boolean;
  agentCoreContractPath?: string;
}
interface StudioTargetGroup {
  kind: 'lambda' | 'api' | 'alb' | 'ecs' | 'ecs-task' | 'cloudfront' | 'agentcore' | 'agentcore-ws';
  title: string;
  entries: StudioTarget[];
}
declare function toStudioTargetGroups(listing: TargetListing): StudioTargetGroup[];
declare function annotatePinnedEcsTargets(groups: StudioTargetGroup[], classify: (targetId: string) => boolean): boolean;
declare function annotateEcsTaskPinnedTargets(groups: StudioTargetGroup[], classify: (targetId: string) => boolean): boolean;
declare function annotateAlbPinnedBackingServices(groups: StudioTargetGroup[], resolveBackingPinned: (albEntry: StudioTarget) => {
  id: string;
  label: string;
}[]): boolean;
declare function filterStudioTargetGroups(groups: StudioTargetGroup[], globs: string[] | undefined): StudioTargetGroup[];
interface StudioServerOptions {
  port: number;
  host?: string;
  bus: StudioEventBus;
  targetGroups: StudioTargetGroup[];
  dockerfiles?: string[];
  appLabel: string;
  cliName: string;
  maxPortBump?: number;
  onRun?: (body: unknown) => Promise<unknown>;
  onStop?: (body: unknown) => Promise<unknown>;
  onServeRequest?: (body: unknown) => Promise<unknown>;
  onReinvoke?: (body: unknown) => Promise<unknown>;
  getRunning?: () => unknown;
  store?: StudioStore;
  getConfig?: () => unknown;
  patchConfig?: (body: unknown) => Promise<unknown>;
}
interface RunningStudioServer {
  url: string;
  port: number;
  close: () => Promise<void>;
  setTargets: (groups: StudioTargetGroup[], dockerfiles?: string[]) => void;
}
declare function startStudioServer(options: StudioServerOptions): Promise<RunningStudioServer>;
//#endregion
//#region src/local/studio-request-relay.d.ts
interface ServeRequestInput {
  baseUrl: string;
  method: string;
  path?: string;
  headers?: Record<string, string>;
  body?: string;
  timeoutMs?: number;
  maxBodyChars?: number;
}
interface ServeRequestResult {
  status: number;
  headers: Record<string, string>;
  body: string;
  truncated: boolean;
  durationMs: number;
}
declare function relayServeRequest(input: ServeRequestInput, fetchFn?: typeof fetch, clock?: () => number): Promise<ServeRequestResult>;
//#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/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/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>;
declare const HOST_DOCKER_INTERNAL_GATEWAY: {
  host: string;
  ip: string;
};
declare function resolveHostGatewayExtraHosts(): Promise<{
  host: string;
  ip: string;
}[]>;
//#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/credential-error.d.ts
declare function describeCredentialLoadFailure(err: unknown): string;
declare function describeAwsFailureForWarn(err: unknown, operation: string): string;
//#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/local/agentcore-ws-bridge.d.ts
interface AgentCoreWsBridgeServerConfig {
  containerHost: string;
  containerPort: number | (() => number);
  host?: string;
  port?: number;
  sessionId?: string;
  authorization?: string;
  path?: string;
  webSocketImpl?: typeof WebSocket;
}
interface RunningAgentCoreWsBridge {
  url: string;
  port: number;
  close(): Promise<void>;
}
interface AttachedAgentCoreWsBridge {
  path: string;
  close(): Promise<void>;
}
declare function attachAgentCoreWsBridge(httpServer: Server, config: Omit<AgentCoreWsBridgeServerConfig, 'host' | 'port'>): AttachedAgentCoreWsBridge;
declare function startAgentCoreWsBridge(config: AgentCoreWsBridgeServerConfig): Promise<RunningAgentCoreWsBridge>;
//#endregion
//#region src/local/agentcore-s3-bundle.d.ts
interface S3BundleLocation {
  bucket: string;
  key: string;
  versionId?: string;
}
interface S3BundleCredentials {
  accessKeyId: string;
  secretAccessKey: string;
  sessionToken?: string;
}
interface DownloadS3BundleOptions {
  region?: string;
  profile?: string;
  credentials?: S3BundleCredentials;
  fetchObject?: (location: S3BundleLocation) => Promise<Uint8Array>;
}
interface ExtractedS3Bundle {
  dir: string;
  cleanup: () => Promise<void>;
}
declare function downloadAndExtractS3Bundle(location: S3BundleLocation, options?: DownloadS3BundleOptions): Promise<ExtractedS3Bundle>;
//#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/image-pin-detector.d.ts
declare function isLocalCdkAssetImage(service: ResolvedEcsService): boolean;
declare function describePinnedImageUri(service: ResolvedEcsService): string | undefined;
interface PinnedTargetEntry {
  target: string;
  label?: string;
}
declare function listPinnedTargets(resolvedServices: Iterable<{
  target: string;
  service: ResolvedEcsService;
}>): PinnedTargetEntry[];
//#endregion
//#region src/local/target-picker.d.ts
interface ResolveParams {
  entries: TargetEntry[];
  message: string;
  noun: string;
  onMissing: () => CdkLocalError;
}
declare function resolveSingleTarget(provided: string | undefined, params: ResolveParams): Promise<string>;
//#endregion
//#region src/local/image-override-engine.d.ts
interface ImageOverrideEntry {
  dockerfile: string;
  contextDir: string;
  buildArgs: Map<string, string>;
  buildSecrets: Map<string, string>;
  targetStage?: string;
}
type ImageOverrideMap = Map<string, ImageOverrideEntry>;
declare class ImageOverrideError extends CdkLocalError {
  constructor(message: string, cause?: Error);
}
interface ImageOverrideGlobals {
  buildArgs: Map<string, string>;
  buildSecrets: Map<string, string>;
  targetStage?: string;
}
interface PerServiceBuildInputs {
  buildArgs: Map<string, string>;
  buildSecrets: Map<string, string>;
  targetStage?: string;
}
interface RawImageOverrideFlags {
  explicit: Map<string, string>;
  pickerPaths: string[];
  globals: ImageOverrideGlobals;
  perService: Map<string, PerServiceBuildInputs>;
}
declare function parseImageOverrideFlags(input: {
  imageOverride?: string[];
  imageBuildArg?: string[];
  imageBuildSecret?: string[];
  imageTarget?: string | string[];
}): RawImageOverrideFlags;
declare function resolveImageOverrides(args: {
  rawFlags: RawImageOverrideFlags;
  pinnedTargets: ReadonlyArray<string>;
  pinnedLabels?: ReadonlyMap<string, string>;
  interactiveBootPrompt?: boolean;
  noInteractive?: boolean;
  cwd?: string;
}): Promise<ImageOverrideMap>;
declare function mergeForService(serviceTarget: string, globals: ImageOverrideGlobals, perService: ReadonlyMap<string, PerServiceBuildInputs>): {
  buildArgs: Map<string, string>;
  buildSecrets: Map<string, string>;
  targetStage?: string;
};
declare function buildImageOverrideTag(serviceTarget: string, entry: ImageOverrideEntry): string;
declare function runImageOverrideBuilds(overrides: ImageOverrideMap): Promise<Map<string, string>>;
declare function enforceImageOverrideOrphans(rawFlags: RawImageOverrideFlags, resolvedOverrides: ImageOverrideMap): void;
//#endregion
//#region src/local/container-log-streamer.d.ts
declare function attachContainerLogStreamer(prefix: string, containerId: string): () => void;
//#endregion
//#region src/local/cloudfront-edge-event.d.ts
type EdgeHeaders = Record<string, Array<{
  key: string;
  value: string;
}>>;
type EdgeEventType = 'viewer-request' | 'origin-request' | 'origin-response' | 'viewer-response';
interface EdgeRequest {
  clientIp: string;
  method: string;
  uri: string;
  querystring: string;
  headers: EdgeHeaders;
  body?: {
    action: 'read-only' | 'replace';
    data: string;
    encoding: 'base64' | 'text';
    inputTruncated: boolean;
  };
}
interface EdgeResponse {
  status: string;
  statusDescription?: string;
  headers: EdgeHeaders;
  body?: string;
  bodyEncoding?: 'text' | 'base64';
}
interface EdgeConfig {
  distributionDomainName: string;
  distributionId: string;
  eventType: EdgeEventType;
  requestId: string;
}
interface EdgeEvent {
  Records: Array<{
    cf: {
      config: EdgeConfig;
      request: EdgeRequest;
      response?: EdgeResponse;
    };
  }>;
}
interface EdgeRequestInput {
  clientIp: string;
  method: string;
  uri: string;
  querystring: string;
  headers: Record<string, string[]>;
  body?: Buffer;
}
declare function httpHeadersToEdge(headers: Record<string, string[]>): EdgeHeaders;
declare function edgeHeadersToHttp(headers: EdgeHeaders): {
  headers: Record<string, string>;
  setCookies: string[];
};
declare function buildEdgeRequestEvent(args: {
  eventType: 'viewer-request' | 'origin-request';
  config: Omit<EdgeConfig, 'eventType'>;
  request: EdgeRequestInput;
  includeBody: boolean;
}): EdgeEvent;
declare function buildEdgeResponseEvent(args: {
  eventType: 'origin-response' | 'viewer-response';
  config: Omit<EdgeConfig, 'eventType'>;
  request: EdgeRequestInput;
  response: {
    statusCode: number;
    headers: Record<string, string>;
  };
}): EdgeEvent;
interface EdgeResponseResult {
  statusCode: number;
  headers: Record<string, string>;
  setCookies: string[];
  body: Buffer;
}
declare function applyEdgeRequestResult(result: unknown, base: EdgeRequestInput): {
  kind: 'continue';
  request: EdgeRequestInput;
} | {
  kind: 'response';
  response: EdgeResponseResult;
};
declare function applyEdgeResponseResult(result: unknown, base: {
  statusCode: number;
  headers: Record<string, string>;
}, originBody: Buffer): EdgeResponseResult;
//#endregion
//#region src/local/cloudfront-kvs-client.d.ts
interface KvsClientCredentials {
  accessKeyId: string;
  secretAccessKey: string;
  sessionToken?: string;
}
interface CreateDeployedKvsDataSourceOptions {
  kvsArn: string;
  kvsId?: string;
  region?: string;
  credentials?: KvsClientCredentials;
}
declare function createDeployedKvsDataSource(options: CreateDeployedKvsDataSourceOptions): KvsDataSource;
declare function resolveDeployedKvsArnByName(name: string, options?: {
  region?: string;
  credentials?: KvsClientCredentials;
}): Promise<{
  arn: string;
  id?: string;
} | undefined>;
//#endregion
//#region src/local/cloudfront-kvs-binding.d.ts
interface DeployedKvsRef {
  arn: string;
  id?: string;
}
interface ResolveKvsModulesOptions {
  kvsFiles?: Map<string, string>;
  resolveDeployedKvs?: (kvsLogicalId: string) => Promise<DeployedKvsRef | undefined>;
  region?: string;
  credentials?: KvsClientCredentials;
}
declare function resolveKvsModulesForDistribution(distribution: ResolvedDistribution, options: ResolveKvsModulesOptions): Promise<{
  warnings: string[];
}>;
declare function idFromArn(arn: string): string | undefined;
//#endregion
//#region src/local/cloudfront-distribution-config.d.ts
interface CloudFrontClientCredentials {
  accessKeyId: string;
  secretAccessKey: string;
  sessionToken?: string;
}
interface ResolveDeployedOriginBucketOptions {
  distributionId: string;
  originId: string;
  credentials?: CloudFrontClientCredentials;
  getOrigins?: (distributionId: string) => Promise<Array<{
    Id?: string;
    DomainName?: string;
  }>>;
}
declare function resolveDeployedOriginBucket(options: ResolveDeployedOriginBucketOptions): Promise<string | undefined>;
//#endregion
//#region src/local/cloudfront-lambda-origin.d.ts
interface LambdaUrlOriginRequest {
  method: string;
  uri: string;
  querystring: string;
  headers: IncomingHttpHeaders;
  body: Buffer;
  sourceIp?: string;
}
interface LambdaUrlOriginResult {
  statusCode: number;
  headers: Record<string, string>;
  cookies: string[];
  body: Buffer;
}
declare function serveLambdaUrlOrigin(args: {
  invoke: (event: Record<string, unknown>) => Promise<unknown>;
  functionUrlLogicalId: string;
  functionLogicalId: string;
  request: LambdaUrlOriginRequest;
}): Promise<LambdaUrlOriginResult>;
//#endregion
//#region src/local/studio-custom-resource-filter.d.ts
declare function isCustomResourceLambdaTarget(entry: StudioTarget): boolean;
interface FilterStudioCustomResourcesOptions {
  include?: boolean;
}
declare function filterStudioCustomResources(groups: StudioTargetGroup[], opts?: FilterStudioCustomResourcesOptions): StudioTargetGroup[];
//#endregion
//#region src/local/studio-ui.d.ts
declare function renderStudioHtml(appLabel: string, cliName: string): string;
//#endregion
//#region src/local/studio-reinvoke.d.ts
interface ReinvokeInput {
  invocationId: string;
  payload: unknown;
}
interface ReinvokeDeps {
  store: StudioStore;
  dispatcher: StudioDispatcher;
}
declare function reinvoke(input: ReinvokeInput, deps: ReinvokeDeps): Promise<StudioRunResult>;
//#endregion
export { A2A_CONTAINER_PORT, A2A_PATH, type A2aInvokeOptions, type A2aInvokeResult, type A2aJsonRpcRequest, AGENTCORE_A2A_PROTOCOL, AGENTCORE_AGUI_PROTOCOL, AGENTCORE_HTTP_PROTOCOL, AGENTCORE_MCP_PROTOCOL, AGENTCORE_RUNTIME_TYPE, AGENTCORE_SESSION_ID_HEADER, AGENTCORE_SIGV4_SERVICE, type AgentCoreCodeArtifact, type AgentCoreCustomClaim, type AgentCoreHttpServerConfig, type AgentCoreInvokeResult, type AgentCoreJwtAuthorizer, AgentCoreResolutionError, type AgentCoreServeAuthCheck, type AgentCoreServeAuthResult, type AgentCoreServeRoute, type AgentCoreServeSignRequest, type AgentCoreWsBridgeHandle, type AgentCoreWsBridgeServerConfig, type AgentCoreWsResult, type ApiServerGroup, type ApiTargetSubset, type AttachedAgentCoreWsBridge, type AuthorizerCache, type AuthorizerEventOverlay, type AuthorizerInfo, type AwsProxyClientConfig, type BridgeAgentCoreWsOptions, type BuildAgentCoreCodeImageOptions, type BuildAgentCoreServeAuthCheckOptions, type BuildContainerImageOptions, CLOUDFRONT_DISTRIBUTION_TYPE, type CachedAuthorizerResult, type CdkWatchConfig, type CfRequest, type CfResponse, type CloudFrontClientCredentials, type CloudFrontKvsAssociation, type CloudFrontKvsHandle, type CloudFrontModule, type CloudMapIndex, CloudMapRegistry, type CompiledCloudFrontFunction, ConnectionRegistry, type ConnectionRegistryEntry, type CorsConfig, type CreateDeployedKvsDataSourceOptions, type CredentialsLoader, DEFAULT_SHADOW_READY_TIMEOUT_MS, type DeployedKvsRef, type DiscoveredRoute, type DiscoveredWebSocketApi, type DiscoveryJwtAuthorizer, type DownloadS3BundleOptions, type EcsServiceEmulatorOptions, EcsTaskResolutionError, type EdgeEvent, type EdgeEventType, type EdgeRequest, type EdgeRequestInput, type EdgeResponse, type EdgeResponseResult, type EmulatorStrategy, type EnvOverrideFile, type ErrorResponseCandidate, type ExtractedS3Bundle, type FileWatcher, type FileWatcherOptions, type FilterStudioCustomResourcesOptions, type FrontDoorForwardTarget, type FrontDoorPlan, HOST_DOCKER_INTERNAL_GATEWAY, HOST_GATEWAY_MIN_VERSION, type HttpRequestSnapshot, type ImageOverrideEntry, ImageOverrideError, type ImageOverrideGlobals, type ImageOverrideMap, type ImageResolutionContext, type IntegrationResponseEntry, type InvokeAgentCoreOptions, type InvokeAgentCoreWsOptions, type JwksCache, type JwtCustomClaim, type KvsDataSource, type LambdaArnResolveOutcome, type LambdaUrlInvokerMap, type LambdaUrlOriginRequest, type LambdaUrlOriginResult, LocalInvokeBuildError, LocalStartCloudFrontError, MAX_TASKS_SUBNET_RANGE_CAP, MCP_CONTAINER_PORT, MCP_PATH, MCP_PROTOCOL_VERSION, type MatchedRouteContext, type McpInvokeOptions, type McpInvokeResult, type McpJsonRpcRequest, type MtlsServerConfig, type PerServiceBuildInputs, type PinnedTargetEntry, type PlannedAction, type PlannedEcsForwardTarget, type PlannedFixedResponseAction, type PlannedForwardAction, type PlannedForwardTarget, type PlannedFrontDoorListener, type PlannedLambdaForwardTarget, type PlannedRedirectAction, type RawImageOverrideFlags, type RegistrationHandle, type ReinvokeDeps, type ReinvokeInput, type ReloadAssetContext, type ReloadVerdict, type RequestParameterContext, type ResolveDeployedOriginBucketOptions, type ResolveKvsModulesOptions, type ResolveParametersOutcome, type ResolvedAgentCoreRuntime, type ResolvedBehavior, type ResolvedCloudFrontFunction, type ResolvedCustomErrorResponse, type ResolvedDistribution, type ResolvedLambdaEdge, type ResolvedLambdaEdgeAssoc, type ResolvedListenerAction, type ResolvedOrigin, type ResolvedStage, type RestV1IntegrationConfig, type RouteMatchResult, type RouteWithAuth, type RunningAgentCoreHttpServer, type RunningAgentCoreWsBridge, type RunningStudioProxy, type RunningStudioServer, type S3BundleCredentials, type S3BundleLocation, type S3FetchResult, type S3ObjectFetcher, type S3OriginCredentials, type S3OriginReader, type S3OriginReaderOptions, SOFT_RELOAD_COMPLETION_LOG_SUFFIX, SUPPORTED_CODE_RUNTIMES, type ServeInboundAuthPlan, type ServeRequestInput, type ServeRequestResult, type ServerState, type ServiceBoot, type SigV4Credentials, type SignAgentCoreInvocationOptions, type SignedAgentCoreHeaders, type StartedApiServer, type StartedCloudFrontServer, type StaticOriginResult, type StudioDispatchConfig, type StudioDispatcher, StudioEventBus, type StudioHistory, type StudioInvocationEvent, type StudioLogEvent, type StudioLogSearchOptions, type StudioProxyConfig, type StudioRunRequest, type StudioRunResult, type StudioServeEvent, type StudioServeManager, type StudioServeManagerConfig, type StudioServeRequest, type StudioServeRequestPayload, type StudioServeState, type StudioServerOptions, type StudioStopRequest, type StudioStore, type StudioStoreOptions, type StudioTarget, type StudioTargetGroup, type StudioTargetKind, type TranslatedHttpResponse, VtlEvaluationError, type WarnedAt, type WatchPredicates, type WebSocketHandshakeSnapshot, type WebSocketLambdaEvent, type WebSocketRouteEntry, a2aInvokeOnce, addAlbSpecificOptions, addCommonEcsServiceOptions, addEcsAssumeRoleOptions, addImageOverrideOptions, addInvokeAgentCoreSpecificOptions, addInvokeSpecificOptions, addListSpecificOptions, addRunTaskSpecificOptions, addStartAgentCoreSpecificOptions, addStartApiSpecificOptions, addStartCloudFrontSpecificOptions, addStartServiceSpecificOptions, addStudioSpecificOptions, albStrategy, annotateAlbPinnedBackingServices, annotateEcsTaskPinnedTargets, annotatePinnedEcsTargets, applyAuthorizerOverlay, applyCorsResponseHeaders, applyEdgeRequestResult, applyEdgeResponseResult, architectureToPlatform, attachAgentCoreWsBridge, attachAuthorizers, attachContainerLogStreamer, attachStageContext, availableApiIdentifiers, availableWebSocketApiIdentifiers, bridgeAgentCoreWs, bufferToBody, buildAgentCoreCodeImage, buildAgentCoreServeAuthCheck, buildCloudMapIndex, buildCognitoJwksUrl, buildConnectEvent, buildContainerImage, buildCorsConfigByApiId, buildCorsConfigFromCloudFrontChain, buildDisconnectEvent, buildEcsImageResolutionContext, buildEdgeRequestEvent, buildEdgeResponseEvent, buildHttpApiV2Event, buildImageOverrideTag, buildJwksUrlFromIssuer, buildMessageEvent, buildMethodArn, buildMgmtEndpointEnvUrl, buildProxyClientConfig, buildRestV1Event, buildStageMap, buildStsClientConfig, classifyS3Error, classifySourceChange, coerceRunRequest, coerceServeRequest, coerceStopRequest, compileCloudFrontFunction, computeCodeImageTag, computeRequestIdentityHash, createAuthorizerCache, createCloudFrontModule, createDeployedKvsDataSource, createFileWatcher, createJwksCache, createLocalFileKvsDataSource, createS3OriginReader, createStudioDispatcher, createStudioServeManager, createStudioStore, createUnboundCloudFrontModule, createWatchPredicates, defaultCredentialsLoader, derivePseudoParametersFromRegion, describeAwsFailureForWarn, describeCredentialLoadFailure, describePinnedImageUri, describeS3OriginDomain, discoverRoutes, discoverWebSocketApis, discoverWebSocketApisOrThrow, downloadAndExtractS3Bundle, ecsClusterOption, edgeHeadersToHttp, enforceImageOverrideOrphans, evaluateCachedLambdaPolicy, evaluateResponseParameters, extractKvsAssociations, filterRoutesByApiIdentifier, filterRoutesByApiIdentifiers, filterStudioCustomResources, filterStudioTargetGroups, filterWebSocketApisByIdentifiers, formatStateRemedy, getContainerNetworkIp, groupRoutesByServer, handleConnectionsRequest, httpHeadersToEdge, idFromArn, invokeAgentCore, invokeAgentCoreWs, invokeRequestAuthorizer, invokeTokenAuthorizer, isApplicationLoadBalancer, isCloudFrontDistribution, isCustomResourceLambdaTarget, isFunctionUrlOacFronted, isLocalCdkAssetImage, isProxyEnvConfigured, listPinnedTargets, matchBehavior, matchPreflight, matchRoute, materializeLayerFromArn, mcpInvokeOnce, mergeForService, normalizeKvsFileKeys, parseConnectionsPath, parseImageOverrideFlags, parseKvsFileOverrides, parseLbPortOverrides, parseMaxTasks, parseOriginOverrides, parseRestartPolicy, parseSelectionExpressionPath, parseSseForJsonRpc, pickAgentCoreCandidateStack, pickFunctionUrlLogicalIdFromOrigin, pickKvsLogicalIdFromArn, pickLambdaEdgeFunctionLogicalId, pickRefLogicalId, pickResponseTemplate, pickTargetFunctionLogicalId, probeHostGatewaySupport, readMtlsMaterialsFromDisk, reinvoke, relayServeRequest, renderCodeDockerfile, renderStudioHtml, resolveAgentCoreTarget, resolveAlbFrontDoor, resolveAlbTarget, resolveApiTargetSubset, resolveCloudFrontDistribution, resolveCloudFrontTarget, resolveDeployedKvsArnByName, resolveDeployedOriginBucket, resolveEcsAssumeRoleOption, resolveEnvVars, resolveErrorResponseCandidates, resolveHostGatewayExtraHosts, resolveImageOverrides, resolveKvsModulesForDistribution, resolveLambdaArnIntrinsic, resolveProfileCredentials, resolveRuntimeCodeMountPath, resolveRuntimeFileExtension, resolveRuntimeImage, resolveSelectionExpression, resolveServeBaseUrl, resolveServiceIntegrationParameters, resolveSharedSidecarCredentials, resolveSingleTarget, resolveWatchConfig, runEcsServiceEmulator, runImageOverrideBuilds, runViewerRequest, runViewerResponse, selectIntegrationResponse, selectServeInboundAuth, serveFromStaticOrigin, serveLambdaUrlOrigin, serviceStrategy, setShadowReadyTimeoutMs, signAgentCoreInvocation, startAgentCoreHttpServer, startAgentCoreWsBridge, startApiServer, startCloudFrontServer, startStudioProxy, startStudioServer, stripCloudFrontImport, substituteImagePlaceholders, toCmdArgv, toStudioTargetGroups, translateLambdaResponse, tryParseStatus, tryResolveImageFnJoin, verifyCognitoJwt, verifyJwtAuthorizer, verifyJwtViaDiscovery, waitForAgentCoreHttpReady, waitForAgentCorePing, webSocketApiMatchesIdentifier };
//# sourceMappingURL=internal.d.ts.map