@kensio/yulin 0.47.0 → 1.0.0

package/dist/service/apigatewayv2/api/route/path/sim-http-api-path-segment-parser.d.ts

@@ -0,0 +1,18 @@
+import type { SimHttpApiPathSegment } from "./sim-http-api-path-segment.js";
+/**
+ * Reads one segment of a route key path.
+ *
+ * A segment is either a literal or a parameter, and anything in between, such
+ * as `{petId` or `pets{id}`, is refused at `CreateRoute`. Real API Gateway
+ * refuses it there too, which is the point of parsing this early rather than
+ * discovering it when a request fails to match.
+ */
+export declare class SimHttpApiPathSegmentParser {
+    /**
+     * Read one path segment, naming the whole route key in anything refused so
+     * the caller can see which route it came from.
+     */
+    parse(text: string, routeKey: string): SimHttpApiPathSegment;
+    private literal;
+}
+//# sourceMappingURL=sim-http-api-path-segment-parser.d.ts.map

package/dist/service/apigatewayv2/api/route/path/sim-http-api-path-segment-parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-http-api-path-segment-parser.d.ts","sourceRoot":"","sources":["../../../../../../src/service/apigatewayv2/api/route/path/sim-http-api-path-segment-parser.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,gCAAgC,CAAC;AAU5E;;;;;;;GAOG;AACH,qBAAa,2BAA2B;IACtC;;;OAGG;IACH,KAAK,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,qBAAqB,CAqB3D;IAED,OAAO,CAAC,OAAO;CAShB"}

package/dist/service/apigatewayv2/api/route/path/sim-http-api-path-segment-parser.js

@@ -0,0 +1,47 @@
+import { SimApiGatewayV2BadRequest } from "../../../error/sim-api-gateway-v2.error.js";
+import { SimHttpApiGreedySegment } from "./sim-http-api-greedy-segment.js";
+import { SimHttpApiLiteralSegment } from "./sim-http-api-literal-segment.js";
+import { SimHttpApiVariableSegment } from "./sim-http-api-variable-segment.js";
+/**
+ * A `{name}` or `{name+}` segment. The name is what reaches the handler as a
+ * path parameter, so it is the character set a JavaScript property name can
+ * hold without quoting.
+ */
+const parameterSegment = /^\{(?<name>[\w.-]+)(?<greedy>\+)?\}$/;
+/**
+ * Reads one segment of a route key path.
+ *
+ * A segment is either a literal or a parameter, and anything in between, such
+ * as `{petId` or `pets{id}`, is refused at `CreateRoute`. Real API Gateway
+ * refuses it there too, which is the point of parsing this early rather than
+ * discovering it when a request fails to match.
+ */
+export class SimHttpApiPathSegmentParser {
+    /**
+     * Read one path segment, naming the whole route key in anything refused so
+     * the caller can see which route it came from.
+     */
+    parse(text, routeKey) {
+        if (!text.includes("{") && !text.includes("}")) {
+            return this.literal(text, routeKey);
+        }
+        const groups = parameterSegment.exec(text)?.groups;
+        const name = groups?.["name"];
+        if (name === undefined) {
+            throw new SimApiGatewayV2BadRequest(`Route key '${routeKey}' has the malformed path segment '${text}': ` +
+                "a segment is either a literal, a {name} parameter, or a {name+} " +
+                "greedy parameter");
+        }
+        if (groups?.["greedy"] === undefined) {
+            return new SimHttpApiVariableSegment(name);
+        }
+        return new SimHttpApiGreedySegment(name);
+    }
+    literal(text, routeKey) {
+        if (text.length === 0) {
+            throw new SimApiGatewayV2BadRequest(`Route key '${routeKey}' has an empty path segment`);
+        }
+        return new SimHttpApiLiteralSegment(text);
+    }
+}
+//# sourceMappingURL=sim-http-api-path-segment-parser.js.map

package/dist/service/apigatewayv2/api/route/path/sim-http-api-path-segment-parser.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-http-api-path-segment-parser.js","sourceRoot":"","sources":["../../../../../../src/service/apigatewayv2/api/route/path/sim-http-api-path-segment-parser.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,yBAAyB,EAAE,MAAM,4CAA4C,CAAC;AACvF,OAAO,EAAE,uBAAuB,EAAE,MAAM,kCAAkC,CAAC;AAC3E,OAAO,EAAE,wBAAwB,EAAE,MAAM,mCAAmC,CAAC;AAE7E,OAAO,EAAE,yBAAyB,EAAE,MAAM,oCAAoC,CAAC;AAE/E;;;;GAIG;AACH,MAAM,gBAAgB,GAAG,sCAAsC,CAAC;AAEhE;;;;;;;GAOG;AACH,MAAM,OAAO,2BAA2B;IACtC;;;OAGG;IACH,KAAK,CAAC,IAAY,EAAE,QAAgB;QAClC,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC;YAC/C,OAAO,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,QAAQ,CAAC,CAAC;QACtC,CAAC;QAED,MAAM,MAAM,GAAG,gBAAgB,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;QACnD,MAAM,IAAI,GAAG,MAAM,EAAE,CAAC,MAAM,CAAC,CAAC;QAE9B,IAAI,IAAI,KAAK,SAAS,EAAE,CAAC;YACvB,MAAM,IAAI,yBAAyB,CACjC,cAAc,QAAQ,qCAAqC,IAAI,KAAK;gBAClE,kEAAkE;gBAClE,kBAAkB,CACrB,CAAC;QACJ,CAAC;QAED,IAAI,MAAM,EAAE,CAAC,QAAQ,CAAC,KAAK,SAAS,EAAE,CAAC;YACrC,OAAO,IAAI,yBAAyB,CAAC,IAAI,CAAC,CAAC;QAC7C,CAAC;QAED,OAAO,IAAI,uBAAuB,CAAC,IAAI,CAAC,CAAC;IAC3C,CAAC;IAEO,OAAO,CAAC,IAAY,EAAE,QAAgB;QAC5C,IAAI,IAAI,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YACtB,MAAM,IAAI,yBAAyB,CACjC,cAAc,QAAQ,6BAA6B,CACpD,CAAC;QACJ,CAAC;QAED,OAAO,IAAI,wBAAwB,CAAC,IAAI,CAAC,CAAC;IAC5C,CAAC;CACF"}

package/dist/service/apigatewayv2/api/route/path/sim-http-api-path-segment.d.ts

@@ -0,0 +1,48 @@
+import type { SimHttpApiPathParameter } from "./sim-http-api-path-parameters.js";
+/**
+ * How specific each kind of path segment is, lower being more specific.
+ *
+ * A literal segment names one path, a `{name}` segment names any one segment,
+ * and a `{proxy+}` segment names everything left. Route selection compares
+ * these segment by segment, rather than counting characters, because it is the
+ * segment where two routes first differ that decides between them.
+ */
+export declare const literalSegmentRank = 0;
+export declare const variableSegmentRank = 1;
+export declare const greedySegmentRank = 2;
+/**
+ * What one route path segment took from the front of a request path.
+ */
+export declare class SimHttpApiSegmentMatch {
+    readonly consumed: number;
+    readonly parameter?: SimHttpApiPathParameter | undefined;
+    constructor(consumed: number, parameter?: SimHttpApiPathParameter);
+}
+/**
+ * One segment of a route path.
+ *
+ * Each kind of segment answers the same questions, so matching a route is a
+ * loop over its segments rather than a switch over segment kinds.
+ */
+export interface SimHttpApiPathSegment {
+    /** How specific this kind of segment is. Lower is more specific. */
+    readonly rank: number;
+    /**
+     * The path parameter this segment captures into, or nothing for a literal,
+     * which captures into none.
+     */
+    readonly parameterName: string | undefined;
+    /**
+     * The segment with any parameter name erased.
+     *
+     * Two route keys differing only in a parameter name are the same route to
+     * real API Gateway, so this is what a route is stored under.
+     */
+    readonly signature: string;
+    /**
+     * Take what this segment matches from the front of the request path segments
+     * it is offered, or nothing when it does not match them.
+     */
+    consume(remaining: readonly string[]): SimHttpApiSegmentMatch | undefined;
+}
+//# sourceMappingURL=sim-http-api-path-segment.d.ts.map

package/dist/service/apigatewayv2/api/route/path/sim-http-api-path-segment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-http-api-path-segment.d.ts","sourceRoot":"","sources":["../../../../../../src/service/apigatewayv2/api/route/path/sim-http-api-path-segment.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,mCAAmC,CAAC;AAEjF;;;;;;;GAOG;AACH,eAAO,MAAM,kBAAkB,IAAI,CAAC;AACpC,eAAO,MAAM,mBAAmB,IAAI,CAAC;AACrC,eAAO,MAAM,iBAAiB,IAAI,CAAC;AAEnC;;GAEG;AACH,qBAAa,sBAAsB;IACjC,SAAgB,QAAQ,EAAE,MAAM,CAAC;IACjC,SAAgB,SAAS,CAAC,EAAE,uBAAuB,GAAG,SAAS,CAAC;IAEhE,YAAY,QAAQ,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,uBAAuB,EAGhE;CACF;AAED;;;;;GAKG;AACH,MAAM,WAAW,qBAAqB;IACpC,oEAAoE;IACpE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB;;;OAGG;IACH,QAAQ,CAAC,aAAa,EAAE,MAAM,GAAG,SAAS,CAAC;IAC3C;;;;;OAKG;IACH,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B;;;OAGG;IACH,OAAO,CAAC,SAAS,EAAE,SAAS,MAAM,EAAE,GAAG,sBAAsB,GAAG,SAAS,CAAC;CAC3E"}

package/dist/service/apigatewayv2/api/route/path/sim-http-api-path-segment.js

@@ -0,0 +1,23 @@
+/**
+ * How specific each kind of path segment is, lower being more specific.
+ *
+ * A literal segment names one path, a `{name}` segment names any one segment,
+ * and a `{proxy+}` segment names everything left. Route selection compares
+ * these segment by segment, rather than counting characters, because it is the
+ * segment where two routes first differ that decides between them.
+ */
+export const literalSegmentRank = 0;
+export const variableSegmentRank = 1;
+export const greedySegmentRank = 2;
+/**
+ * What one route path segment took from the front of a request path.
+ */
+export class SimHttpApiSegmentMatch {
+    consumed;
+    parameter;
+    constructor(consumed, parameter) {
+        this.consumed = consumed;
+        this.parameter = parameter;
+    }
+}
+//# sourceMappingURL=sim-http-api-path-segment.js.map

package/dist/service/apigatewayv2/api/route/path/sim-http-api-path-segment.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-http-api-path-segment.js","sourceRoot":"","sources":["../../../../../../src/service/apigatewayv2/api/route/path/sim-http-api-path-segment.ts"],"names":[],"mappings":"AAEA;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG,CAAC,CAAC;AACpC,MAAM,CAAC,MAAM,mBAAmB,GAAG,CAAC,CAAC;AACrC,MAAM,CAAC,MAAM,iBAAiB,GAAG,CAAC,CAAC;AAEnC;;GAEG;AACH,MAAM,OAAO,sBAAsB;IACjB,QAAQ,CAAS;IACjB,SAAS,CAAuC;IAEhE,YAAY,QAAgB,EAAE,SAAmC;QAC/D,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC;QACzB,IAAI,CAAC,SAAS,GAAG,SAAS,CAAC;IAC7B,CAAC;CACF"}

package/dist/service/apigatewayv2/api/route/path/sim-http-api-path-segments.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Split a URL path into the segments route matching works through.
+ *
+ * A leading slash produces no segment, so `/pets/dog` is `pets` then `dog`,
+ * and `/` is no segments at all. One trailing slash is dropped, so `/pets/`
+ * and `/pets` are the same path. That last part is observed rather than
+ * documented: real API Gateway matches both to the same route.
+ */
+export declare function simHttpApiPathSegments(path: string): string[];
+//# sourceMappingURL=sim-http-api-path-segments.d.ts.map

package/dist/service/apigatewayv2/api/route/path/sim-http-api-path-segments.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-http-api-path-segments.d.ts","sourceRoot":"","sources":["../../../../../../src/service/apigatewayv2/api/route/path/sim-http-api-path-segments.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAW7D"}

package/dist/service/apigatewayv2/api/route/path/sim-http-api-path-segments.js

@@ -0,0 +1,19 @@
+/**
+ * Split a URL path into the segments route matching works through.
+ *
+ * A leading slash produces no segment, so `/pets/dog` is `pets` then `dog`,
+ * and `/` is no segments at all. One trailing slash is dropped, so `/pets/`
+ * and `/pets` are the same path. That last part is observed rather than
+ * documented: real API Gateway matches both to the same route.
+ */
+export function simHttpApiPathSegments(path) {
+    // The leading slash is taken off rather than tested for: a URL pathname
+    // always has one, and a route key path without one is refused before this
+    // is reached.
+    const segments = path.slice(1).split("/");
+    if (segments.at(-1) === "") {
+        segments.pop();
+    }
+    return segments;
+}
+//# sourceMappingURL=sim-http-api-path-segments.js.map

package/dist/service/apigatewayv2/api/route/path/sim-http-api-path-segments.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-http-api-path-segments.js","sourceRoot":"","sources":["../../../../../../src/service/apigatewayv2/api/route/path/sim-http-api-path-segments.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AACH,MAAM,UAAU,sBAAsB,CAAC,IAAY;IACjD,wEAAwE;IACxE,0EAA0E;IAC1E,cAAc;IACd,MAAM,QAAQ,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;IAE1C,IAAI,QAAQ,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC;QAC3B,QAAQ,CAAC,GAAG,EAAE,CAAC;IACjB,CAAC;IAED,OAAO,QAAQ,CAAC;AAClB,CAAC"}

package/dist/service/apigatewayv2/api/route/path/sim-http-api-route-path-parser.d.ts

@@ -0,0 +1,29 @@
+import { SimHttpApiRoutePath } from "./sim-http-api-route-path.js";
+/**
+ * Reads the path half of a route key into the segments it is made of.
+ */
+export declare class SimHttpApiRoutePathParser {
+    private readonly segmentParser;
+    /**
+     * Read a route key path, naming the whole route key in anything refused.
+     */
+    parse(path: string, routeKey: string): SimHttpApiRoutePath;
+    /**
+     * Refuse a path naming the same parameter twice.
+     *
+     * A handler reads path parameters off one object, so `GET /pets/{id}/toys/{id}`
+     * has one `id` to put two captures in. Accepting it would silently keep one
+     * segment and lose the other, which is the kind of quietly wrong behaviour
+     * refusing exists to avoid. Whether real API Gateway refuses it is not
+     * established, so this is stricter than AWS rather than known to match it.
+     */
+    private requireDistinctParameterNames;
+    /**
+     * Refuse a greedy segment anywhere but the end.
+     *
+     * A `{proxy+}` takes everything left of the path, so a segment after it
+     * could never match anything.
+     */
+    private requireGreedyLast;
+}
+//# sourceMappingURL=sim-http-api-route-path-parser.d.ts.map

package/dist/service/apigatewayv2/api/route/path/sim-http-api-route-path-parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-http-api-route-path-parser.d.ts","sourceRoot":"","sources":["../../../../../../src/service/apigatewayv2/api/route/path/sim-http-api-route-path-parser.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,mBAAmB,EAAE,MAAM,8BAA8B,CAAC;AAEnE;;GAEG;AACH,qBAAa,yBAAyB;IACpC,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAqC;IAEnE;;OAEG;IACH,KAAK,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,mBAAmB,CAezD;IAED;;;;;;;;OAQG;IACH,OAAO,CAAC,6BAA6B;IAuBrC;;;;;OAKG;IACH,OAAO,CAAC,iBAAiB;CAkB1B"}

package/dist/service/apigatewayv2/api/route/path/sim-http-api-route-path-parser.js

@@ -0,0 +1,63 @@
+import { SimApiGatewayV2BadRequest } from "../../../error/sim-api-gateway-v2.error.js";
+import { SimHttpApiPathSegmentParser } from "./sim-http-api-path-segment-parser.js";
+import { greedySegmentRank } from "./sim-http-api-path-segment.js";
+import { simHttpApiPathSegments } from "./sim-http-api-path-segments.js";
+import { SimHttpApiRoutePath } from "./sim-http-api-route-path.js";
+/**
+ * Reads the path half of a route key into the segments it is made of.
+ */
+export class SimHttpApiRoutePathParser {
+    segmentParser = new SimHttpApiPathSegmentParser();
+    /**
+     * Read a route key path, naming the whole route key in anything refused.
+     */
+    parse(path, routeKey) {
+        if (!path.startsWith("/")) {
+            throw new SimApiGatewayV2BadRequest(`Route key '${routeKey}' has the path '${path}', which does not ` +
+                `start with a slash`);
+        }
+        const segments = simHttpApiPathSegments(path).map((text) => this.segmentParser.parse(text, routeKey));
+        this.requireGreedyLast(segments, routeKey);
+        this.requireDistinctParameterNames(segments, routeKey);
+        return new SimHttpApiRoutePath({ text: path, segments });
+    }
+    /**
+     * Refuse a path naming the same parameter twice.
+     *
+     * A handler reads path parameters off one object, so `GET /pets/{id}/toys/{id}`
+     * has one `id` to put two captures in. Accepting it would silently keep one
+     * segment and lose the other, which is the kind of quietly wrong behaviour
+     * refusing exists to avoid. Whether real API Gateway refuses it is not
+     * established, so this is stricter than AWS rather than known to match it.
+     */
+    requireDistinctParameterNames(segments, routeKey) {
+        const named = new Set();
+        for (const { parameterName } of segments) {
+            if (parameterName === undefined) {
+                continue;
+            }
+            if (named.has(parameterName)) {
+                throw new SimApiGatewayV2BadRequest(`Route key '${routeKey}' names the path parameter ` +
+                    `'${parameterName}' more than once: a handler reads path ` +
+                    `parameters off one object, so only one of them could arrive`);
+            }
+            named.add(parameterName);
+        }
+    }
+    /**
+     * Refuse a greedy segment anywhere but the end.
+     *
+     * A `{proxy+}` takes everything left of the path, so a segment after it
+     * could never match anything.
+     */
+    requireGreedyLast(segments, routeKey) {
+        const greedyAt = segments.findIndex((segment) => segment.rank === greedySegmentRank);
+        if (greedyAt === -1 || greedyAt === segments.length - 1) {
+            return;
+        }
+        throw new SimApiGatewayV2BadRequest(`Route key '${routeKey}' has a greedy path parameter before the end of ` +
+            `the path: a {name+} parameter takes the rest of the path, so nothing ` +
+            `can follow it`);
+    }
+}
+//# sourceMappingURL=sim-http-api-route-path-parser.js.map

package/dist/service/apigatewayv2/api/route/path/sim-http-api-route-path-parser.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-http-api-route-path-parser.js","sourceRoot":"","sources":["../../../../../../src/service/apigatewayv2/api/route/path/sim-http-api-route-path-parser.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,yBAAyB,EAAE,MAAM,4CAA4C,CAAC;AACvF,OAAO,EAAE,2BAA2B,EAAE,MAAM,uCAAuC,CAAC;AACpF,OAAO,EAAE,iBAAiB,EAAE,MAAM,gCAAgC,CAAC;AAEnE,OAAO,EAAE,sBAAsB,EAAE,MAAM,iCAAiC,CAAC;AACzE,OAAO,EAAE,mBAAmB,EAAE,MAAM,8BAA8B,CAAC;AAEnE;;GAEG;AACH,MAAM,OAAO,yBAAyB;IACnB,aAAa,GAAG,IAAI,2BAA2B,EAAE,CAAC;IAEnE;;OAEG;IACH,KAAK,CAAC,IAAY,EAAE,QAAgB;QAClC,IAAI,CAAC,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,EAAE,CAAC;YAC1B,MAAM,IAAI,yBAAyB,CACjC,cAAc,QAAQ,mBAAmB,IAAI,oBAAoB;gBAC/D,oBAAoB,CACvB,CAAC;QACJ,CAAC;QAED,MAAM,QAAQ,GAAG,sBAAsB,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CACzD,IAAI,CAAC,aAAa,CAAC,KAAK,CAAC,IAAI,EAAE,QAAQ,CAAC,CACzC,CAAC;QACF,IAAI,CAAC,iBAAiB,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAC;QAC3C,IAAI,CAAC,6BAA6B,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAC;QAEvD,OAAO,IAAI,mBAAmB,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAC,CAAC;IAC3D,CAAC;IAED;;;;;;;;OAQG;IACK,6BAA6B,CACnC,QAA0C,EAC1C,QAAgB;QAEhB,MAAM,KAAK,GAAG,IAAI,GAAG,EAAU,CAAC;QAEhC,KAAK,MAAM,EAAE,aAAa,EAAE,IAAI,QAAQ,EAAE,CAAC;YACzC,IAAI,aAAa,KAAK,SAAS,EAAE,CAAC;gBAChC,SAAS;YACX,CAAC;YAED,IAAI,KAAK,CAAC,GAAG,CAAC,aAAa,CAAC,EAAE,CAAC;gBAC7B,MAAM,IAAI,yBAAyB,CACjC,cAAc,QAAQ,6BAA6B;oBACjD,IAAI,aAAa,yCAAyC;oBAC1D,6DAA6D,CAChE,CAAC;YACJ,CAAC;YAED,KAAK,CAAC,GAAG,CAAC,aAAa,CAAC,CAAC;QAC3B,CAAC;IACH,CAAC;IAED;;;;;OAKG;IACK,iBAAiB,CACvB,QAA0C,EAC1C,QAAgB;QAEhB,MAAM,QAAQ,GAAG,QAAQ,CAAC,SAAS,CACjC,CAAC,OAAO,EAAE,EAAE,CAAC,OAAO,CAAC,IAAI,KAAK,iBAAiB,CAChD,CAAC;QAEF,IAAI,QAAQ,KAAK,CAAC,CAAC,IAAI,QAAQ,KAAK,QAAQ,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YACxD,OAAO;QACT,CAAC;QAED,MAAM,IAAI,yBAAyB,CACjC,cAAc,QAAQ,kDAAkD;YACtE,uEAAuE;YACvE,eAAe,CAClB,CAAC;IACJ,CAAC;CACF"}

package/dist/service/apigatewayv2/api/route/path/sim-http-api-route-path.d.ts

@@ -0,0 +1,42 @@
+import { SimHttpApiPathParameters } from "./sim-http-api-path-parameters.js";
+import { type SimHttpApiPathSegment } from "./sim-http-api-path-segment.js";
+interface SimHttpApiRoutePathProperties {
+    readonly text: string;
+    readonly segments: readonly SimHttpApiPathSegment[];
+}
+/**
+ * The path half of a route key, such as `/pets/{petId}`.
+ *
+ * The text is kept as the route key gave it, since that is what `RouteKey`
+ * reports back and what reaches the handler as `event.routeKey`.
+ */
+export declare class SimHttpApiRoutePath {
+    readonly text: string;
+    readonly segments: readonly SimHttpApiPathSegment[];
+    constructor(properties: SimHttpApiRoutePathProperties);
+    /**
+     * This path with every parameter name erased, which is what makes two route
+     * keys differing only in parameter name the same route.
+     */
+    get signature(): string;
+    /**
+     * How specific each segment is, in order, for route selection to compare.
+     */
+    get segmentRanks(): readonly number[];
+    /**
+     * Whether this path ends in a greedy segment, which puts it behind every
+     * fully matching route.
+     */
+    get hasGreedySegment(): boolean;
+    /**
+     * Match this path against the segments of one request path, capturing
+     * whatever its parameters name.
+     *
+     * The request has to be used up exactly: a path with segments left over
+     * matches nothing, which is what keeps `GET /pets` from matching
+     * `/pets/dog`.
+     */
+    match(requestSegments: readonly string[]): SimHttpApiPathParameters | undefined;
+}
+export {};
+//# sourceMappingURL=sim-http-api-route-path.d.ts.map

package/dist/service/apigatewayv2/api/route/path/sim-http-api-route-path.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-http-api-route-path.d.ts","sourceRoot":"","sources":["../../../../../../src/service/apigatewayv2/api/route/path/sim-http-api-route-path.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,wBAAwB,EAAE,MAAM,mCAAmC,CAAC;AAC7E,OAAO,EAEL,KAAK,qBAAqB,EAC3B,MAAM,gCAAgC,CAAC;AAExC,UAAU,6BAA6B;IACrC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,QAAQ,EAAE,SAAS,qBAAqB,EAAE,CAAC;CACrD;AAED;;;;;GAKG;AACH,qBAAa,mBAAmB;IAC9B,SAAgB,IAAI,EAAE,MAAM,CAAC;IAC7B,SAAgB,QAAQ,EAAE,SAAS,qBAAqB,EAAE,CAAC;IAE3D,YAAY,UAAU,EAAE,6BAA6B,EAGpD;IAED;;;OAGG;IACH,IAAI,SAAS,IAAI,MAAM,CAEtB;IAED;;OAEG;IACH,IAAI,YAAY,IAAI,SAAS,MAAM,EAAE,CAEpC;IAED;;;OAGG;IACH,IAAI,gBAAgB,IAAI,OAAO,CAE9B;IAED;;;;;;;OAOG;IACH,KAAK,CACH,eAAe,EAAE,SAAS,MAAM,EAAE,GACjC,wBAAwB,GAAG,SAAS,CAoBtC;CACF"}

package/dist/service/apigatewayv2/api/route/path/sim-http-api-route-path.js

@@ -0,0 +1,61 @@
+import { SimHttpApiPathParameters } from "./sim-http-api-path-parameters.js";
+import { greedySegmentRank, } from "./sim-http-api-path-segment.js";
+/**
+ * The path half of a route key, such as `/pets/{petId}`.
+ *
+ * The text is kept as the route key gave it, since that is what `RouteKey`
+ * reports back and what reaches the handler as `event.routeKey`.
+ */
+export class SimHttpApiRoutePath {
+    text;
+    segments;
+    constructor(properties) {
+        this.text = properties.text;
+        this.segments = properties.segments;
+    }
+    /**
+     * This path with every parameter name erased, which is what makes two route
+     * keys differing only in parameter name the same route.
+     */
+    get signature() {
+        return `/${this.segments.map((segment) => segment.signature).join("/")}`;
+    }
+    /**
+     * How specific each segment is, in order, for route selection to compare.
+     */
+    get segmentRanks() {
+        return this.segments.map((segment) => segment.rank);
+    }
+    /**
+     * Whether this path ends in a greedy segment, which puts it behind every
+     * fully matching route.
+     */
+    get hasGreedySegment() {
+        return this.segments.some((segment) => segment.rank === greedySegmentRank);
+    }
+    /**
+     * Match this path against the segments of one request path, capturing
+     * whatever its parameters name.
+     *
+     * The request has to be used up exactly: a path with segments left over
+     * matches nothing, which is what keeps `GET /pets` from matching
+     * `/pets/dog`.
+     */
+    match(requestSegments) {
+        const parameters = new SimHttpApiPathParameters();
+        let taken = 0;
+        for (const segment of this.segments) {
+            const matched = segment.consume(requestSegments.slice(taken));
+            if (matched === undefined) {
+                return undefined;
+            }
+            parameters.add(matched.parameter);
+            taken += matched.consumed;
+        }
+        if (taken !== requestSegments.length) {
+            return undefined;
+        }
+        return parameters;
+    }
+}
+//# sourceMappingURL=sim-http-api-route-path.js.map

package/dist/service/apigatewayv2/api/route/path/sim-http-api-route-path.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-http-api-route-path.js","sourceRoot":"","sources":["../../../../../../src/service/apigatewayv2/api/route/path/sim-http-api-route-path.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,wBAAwB,EAAE,MAAM,mCAAmC,CAAC;AAC7E,OAAO,EACL,iBAAiB,GAElB,MAAM,gCAAgC,CAAC;AAOxC;;;;;GAKG;AACH,MAAM,OAAO,mBAAmB;IACd,IAAI,CAAS;IACb,QAAQ,CAAmC;IAE3D,YAAY,UAAyC;QACnD,IAAI,CAAC,IAAI,GAAG,UAAU,CAAC,IAAI,CAAC;QAC5B,IAAI,CAAC,QAAQ,GAAG,UAAU,CAAC,QAAQ,CAAC;IACtC,CAAC;IAED;;;OAGG;IACH,IAAI,SAAS;QACX,OAAO,IAAI,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC;IAC3E,CAAC;IAED;;OAEG;IACH,IAAI,YAAY;QACd,OAAO,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;IACtD,CAAC;IAED;;;OAGG;IACH,IAAI,gBAAgB;QAClB,OAAO,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,OAAO,EAAE,EAAE,CAAC,OAAO,CAAC,IAAI,KAAK,iBAAiB,CAAC,CAAC;IAC7E,CAAC;IAED;;;;;;;OAOG;IACH,KAAK,CACH,eAAkC;QAElC,MAAM,UAAU,GAAG,IAAI,wBAAwB,EAAE,CAAC;QAClD,IAAI,KAAK,GAAG,CAAC,CAAC;QAEd,KAAK,MAAM,OAAO,IAAI,IAAI,CAAC,QAAQ,EAAE,CAAC;YACpC,MAAM,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,eAAe,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC;YAE9D,IAAI,OAAO,KAAK,SAAS,EAAE,CAAC;gBAC1B,OAAO,SAAS,CAAC;YACnB,CAAC;YAED,UAAU,CAAC,GAAG,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC;YAClC,KAAK,IAAI,OAAO,CAAC,QAAQ,CAAC;QAC5B,CAAC;QAED,IAAI,KAAK,KAAK,eAAe,CAAC,MAAM,EAAE,CAAC;YACrC,OAAO,SAAS,CAAC;QACnB,CAAC;QAED,OAAO,UAAU,CAAC;IACpB,CAAC;CACF"}

package/dist/service/apigatewayv2/api/route/path/sim-http-api-variable-segment.d.ts

@@ -0,0 +1,23 @@
+import { type SimHttpApiPathSegment, SimHttpApiSegmentMatch } from "./sim-http-api-path-segment.js";
+/**
+ * A route path segment capturing one path segment, such as `{petId}`.
+ *
+ * It matches exactly one segment, whatever is in it, and the value reaches the
+ * handler as `event.pathParameters.petId`.
+ */
+export declare class SimHttpApiVariableSegment implements SimHttpApiPathSegment {
+    readonly rank = 1;
+    /**
+     * Every parameter segment has the same signature, whatever the name is, so
+     * `GET /pets/{id}` and `GET /pets/{petId}` are one route.
+     */
+    readonly signature = "{}";
+    readonly parameterName: string;
+    constructor(parameterName: string);
+    /**
+     * Take the one request segment this parameter names, when there is one with
+     * something in it.
+     */
+    consume(remaining: readonly string[]): SimHttpApiSegmentMatch | undefined;
+}
+//# sourceMappingURL=sim-http-api-variable-segment.d.ts.map

package/dist/service/apigatewayv2/api/route/path/sim-http-api-variable-segment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-http-api-variable-segment.d.ts","sourceRoot":"","sources":["../../../../../../src/service/apigatewayv2/api/route/path/sim-http-api-variable-segment.ts"],"names":[],"mappings":"AACA,OAAO,EACL,KAAK,qBAAqB,EAC1B,sBAAsB,EAEvB,MAAM,gCAAgC,CAAC;AAExC;;;;;GAKG;AACH,qBAAa,yBAA0B,YAAW,qBAAqB;IACrE,SAAgB,IAAI,KAAuB;IAC3C;;;OAGG;IACH,SAAgB,SAAS,QAAQ;IACjC,SAAgB,aAAa,EAAE,MAAM,CAAC;IAEtC,YAAY,aAAa,EAAE,MAAM,EAEhC;IAED;;;OAGG;IACH,OAAO,CAAC,SAAS,EAAE,SAAS,MAAM,EAAE,GAAG,sBAAsB,GAAG,SAAS,CAWxE;CACF"}

package/dist/service/apigatewayv2/api/route/path/sim-http-api-variable-segment.js

@@ -0,0 +1,32 @@
+import { SimHttpApiPathParameter } from "./sim-http-api-path-parameters.js";
+import { SimHttpApiSegmentMatch, variableSegmentRank, } from "./sim-http-api-path-segment.js";
+/**
+ * A route path segment capturing one path segment, such as `{petId}`.
+ *
+ * It matches exactly one segment, whatever is in it, and the value reaches the
+ * handler as `event.pathParameters.petId`.
+ */
+export class SimHttpApiVariableSegment {
+    rank = variableSegmentRank;
+    /**
+     * Every parameter segment has the same signature, whatever the name is, so
+     * `GET /pets/{id}` and `GET /pets/{petId}` are one route.
+     */
+    signature = "{}";
+    parameterName;
+    constructor(parameterName) {
+        this.parameterName = parameterName;
+    }
+    /**
+     * Take the one request segment this parameter names, when there is one with
+     * something in it.
+     */
+    consume(remaining) {
+        const [value] = remaining;
+        if (value === undefined || value.length === 0) {
+            return undefined;
+        }
+        return new SimHttpApiSegmentMatch(1, new SimHttpApiPathParameter(this.parameterName, value));
+    }
+}
+//# sourceMappingURL=sim-http-api-variable-segment.js.map

package/dist/service/apigatewayv2/api/route/path/sim-http-api-variable-segment.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-http-api-variable-segment.js","sourceRoot":"","sources":["../../../../../../src/service/apigatewayv2/api/route/path/sim-http-api-variable-segment.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,uBAAuB,EAAE,MAAM,mCAAmC,CAAC;AAC5E,OAAO,EAEL,sBAAsB,EACtB,mBAAmB,GACpB,MAAM,gCAAgC,CAAC;AAExC;;;;;GAKG;AACH,MAAM,OAAO,yBAAyB;IACpB,IAAI,GAAG,mBAAmB,CAAC;IAC3C;;;OAGG;IACa,SAAS,GAAG,IAAI,CAAC;IACjB,aAAa,CAAS;IAEtC,YAAY,aAAqB;QAC/B,IAAI,CAAC,aAAa,GAAG,aAAa,CAAC;IACrC,CAAC;IAED;;;OAGG;IACH,OAAO,CAAC,SAA4B;QAClC,MAAM,CAAC,KAAK,CAAC,GAAG,SAAS,CAAC;QAE1B,IAAI,KAAK,KAAK,SAAS,IAAI,KAAK,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YAC9C,OAAO,SAAS,CAAC;QACnB,CAAC;QAED,OAAO,IAAI,sBAAsB,CAC/B,CAAC,EACD,IAAI,uBAAuB,CAAC,IAAI,CAAC,aAAa,EAAE,KAAK,CAAC,CACvD,CAAC;IACJ,CAAC;CACF"}

package/dist/service/apigatewayv2/api/route/sim-http-api-route-rank.d.ts

@@ -0,0 +1,47 @@
+/**
+ * The three tiers AWS documents for route selection, most specific first: a
+ * route matching the whole path, a route ending in a greedy parameter, then
+ * the `$default` catch-all.
+ */
+export declare const fullMatchTier = 0;
+export declare const greedyMatchTier = 1;
+export declare const defaultRouteTier = 2;
+interface SimHttpApiRouteRankProperties {
+    readonly tier: number;
+    readonly methodRank: number;
+    readonly segmentRanks: readonly number[];
+}
+/**
+ * How specific one route is, and therefore which of two matching routes serves
+ * a request.
+ *
+ * The whole precedence rule lives in `compareTo`, in the order it is applied:
+ *
+ * 1. The tier. AWS documents this one: a full match beats a greedy match,
+ *    which beats `$default`.
+ * 2. The method. An exact method beats `ANY`. Observed rather than documented,
+ *    as is its place above the path comparison rather than below it.
+ * 3. The path, segment by segment from the left, with a literal beating a
+ *    `{name}` parameter and a `{name}` beating a `{name+}`. The first two rows
+ *    of AWS's worked example give the literal-beats-parameter part. Comparing
+ *    left to right rather than counting characters is what makes
+ *    `GET /a/b/{c}` beat `GET /a/{b}/ccccc`, which has more literal characters
+ *    and is less specific where it counts. It is also what gives the observed
+ *    rule that the longest literal prefix wins between two greedy routes:
+ *    `GET /pets/dog/{proxy+}` and `GET /pets/{proxy+}` differ at the second
+ *    segment, where one has a literal and the other has taken everything.
+ */
+export declare class SimHttpApiRouteRank {
+    readonly tier: number;
+    readonly methodRank: number;
+    readonly segmentRanks: readonly number[];
+    constructor(properties: SimHttpApiRouteRankProperties);
+    /**
+     * Compare this rank with another, negative meaning this one is more specific
+     * and therefore wins.
+     */
+    compareTo(other: SimHttpApiRouteRank): number;
+    private compareSegments;
+}
+export {};
+//# sourceMappingURL=sim-http-api-route-rank.d.ts.map

package/dist/service/apigatewayv2/api/route/sim-http-api-route-rank.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-http-api-route-rank.d.ts","sourceRoot":"","sources":["../../../../../src/service/apigatewayv2/api/route/sim-http-api-route-rank.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,eAAO,MAAM,aAAa,IAAI,CAAC;AAC/B,eAAO,MAAM,eAAe,IAAI,CAAC;AACjC,eAAO,MAAM,gBAAgB,IAAI,CAAC;AAElC,UAAU,6BAA6B;IACrC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,YAAY,EAAE,SAAS,MAAM,EAAE,CAAC;CAC1C;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,qBAAa,mBAAmB;IAC9B,SAAgB,IAAI,EAAE,MAAM,CAAC;IAC7B,SAAgB,UAAU,EAAE,MAAM,CAAC;IACnC,SAAgB,YAAY,EAAE,SAAS,MAAM,EAAE,CAAC;IAEhD,YAAY,UAAU,EAAE,6BAA6B,EAIpD;IAED;;;OAGG;IACH,SAAS,CAAC,KAAK,EAAE,mBAAmB,GAAG,MAAM,CAU5C;IAED,OAAO,CAAC,eAAe;CAoBxB"}

package/dist/service/apigatewayv2/api/route/sim-http-api-route-rank.js

@@ -0,0 +1,66 @@
+/**
+ * The three tiers AWS documents for route selection, most specific first: a
+ * route matching the whole path, a route ending in a greedy parameter, then
+ * the `$default` catch-all.
+ */
+export const fullMatchTier = 0;
+export const greedyMatchTier = 1;
+export const defaultRouteTier = 2;
+/**
+ * How specific one route is, and therefore which of two matching routes serves
+ * a request.
+ *
+ * The whole precedence rule lives in `compareTo`, in the order it is applied:
+ *
+ * 1. The tier. AWS documents this one: a full match beats a greedy match,
+ *    which beats `$default`.
+ * 2. The method. An exact method beats `ANY`. Observed rather than documented,
+ *    as is its place above the path comparison rather than below it.
+ * 3. The path, segment by segment from the left, with a literal beating a
+ *    `{name}` parameter and a `{name}` beating a `{name+}`. The first two rows
+ *    of AWS's worked example give the literal-beats-parameter part. Comparing
+ *    left to right rather than counting characters is what makes
+ *    `GET /a/b/{c}` beat `GET /a/{b}/ccccc`, which has more literal characters
+ *    and is less specific where it counts. It is also what gives the observed
+ *    rule that the longest literal prefix wins between two greedy routes:
+ *    `GET /pets/dog/{proxy+}` and `GET /pets/{proxy+}` differ at the second
+ *    segment, where one has a literal and the other has taken everything.
+ */
+export class SimHttpApiRouteRank {
+    tier;
+    methodRank;
+    segmentRanks;
+    constructor(properties) {
+        this.tier = properties.tier;
+        this.methodRank = properties.methodRank;
+        this.segmentRanks = properties.segmentRanks;
+    }
+    /**
+     * Compare this rank with another, negative meaning this one is more specific
+     * and therefore wins.
+     */
+    compareTo(other) {
+        if (this.tier !== other.tier) {
+            return this.tier - other.tier;
+        }
+        if (this.methodRank !== other.methodRank) {
+            return this.methodRank - other.methodRank;
+        }
+        return this.compareSegments(other);
+    }
+    compareSegments(other) {
+        const shared = Math.min(this.segmentRanks.length, other.segmentRanks.length);
+        for (let index = 0; index < shared; index++) {
+            const mine = this.segmentRanks.at(index) ?? 0;
+            const theirs = other.segmentRanks.at(index) ?? 0;
+            if (mine !== theirs) {
+                return mine - theirs;
+            }
+        }
+        /* v8 ignore next -- two routes matching one request always differ
+           somewhere in the segments they share: if they did not, they would be the
+           same route key, and the second is refused as a conflict */
+        return 0;
+    }
+}
+//# sourceMappingURL=sim-http-api-route-rank.js.map

package/dist/service/apigatewayv2/api/route/sim-http-api-route-rank.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-http-api-route-rank.js","sourceRoot":"","sources":["../../../../../src/service/apigatewayv2/api/route/sim-http-api-route-rank.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,MAAM,CAAC,MAAM,aAAa,GAAG,CAAC,CAAC;AAC/B,MAAM,CAAC,MAAM,eAAe,GAAG,CAAC,CAAC;AACjC,MAAM,CAAC,MAAM,gBAAgB,GAAG,CAAC,CAAC;AAQlC;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,OAAO,mBAAmB;IACd,IAAI,CAAS;IACb,UAAU,CAAS;IACnB,YAAY,CAAoB;IAEhD,YAAY,UAAyC;QACnD,IAAI,CAAC,IAAI,GAAG,UAAU,CAAC,IAAI,CAAC;QAC5B,IAAI,CAAC,UAAU,GAAG,UAAU,CAAC,UAAU,CAAC;QACxC,IAAI,CAAC,YAAY,GAAG,UAAU,CAAC,YAAY,CAAC;IAC9C,CAAC;IAED;;;OAGG;IACH,SAAS,CAAC,KAA0B;QAClC,IAAI,IAAI,CAAC,IAAI,KAAK,KAAK,CAAC,IAAI,EAAE,CAAC;YAC7B,OAAO,IAAI,CAAC,IAAI,GAAG,KAAK,CAAC,IAAI,CAAC;QAChC,CAAC;QAED,IAAI,IAAI,CAAC,UAAU,KAAK,KAAK,CAAC,UAAU,EAAE,CAAC;YACzC,OAAO,IAAI,CAAC,UAAU,GAAG,KAAK,CAAC,UAAU,CAAC;QAC5C,CAAC;QAED,OAAO,IAAI,CAAC,eAAe,CAAC,KAAK,CAAC,CAAC;IACrC,CAAC;IAEO,eAAe,CAAC,KAA0B;QAChD,MAAM,MAAM,GAAG,IAAI,CAAC,GAAG,CACrB,IAAI,CAAC,YAAY,CAAC,MAAM,EACxB,KAAK,CAAC,YAAY,CAAC,MAAM,CAC1B,CAAC;QAEF,KAAK,IAAI,KAAK,GAAG,CAAC,EAAE,KAAK,GAAG,MAAM,EAAE,KAAK,EAAE,EAAE,CAAC;YAC5C,MAAM,IAAI,GAAG,IAAI,CAAC,YAAY,CAAC,EAAE,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;YAC9C,MAAM,MAAM,GAAG,KAAK,CAAC,YAAY,CAAC,EAAE,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;YAEjD,IAAI,IAAI,KAAK,MAAM,EAAE,CAAC;gBACpB,OAAO,IAAI,GAAG,MAAM,CAAC;YACvB,CAAC;QACH,CAAC;QAED;;qEAE6D;QAC7D,OAAO,CAAC,CAAC;IACX,CAAC;CACF"}

package/dist/service/apigatewayv2/api/route/sim-http-api-route-request.d.ts

@@ -0,0 +1,18 @@
+interface SimHttpApiRouteRequestProperties {
+    readonly method: string;
+    readonly segments: readonly string[];
+}
+/**
+ * One request as route selection sees it: the HTTP method, and the path
+ * segments left once the stage has taken its own.
+ *
+ * A named stage is a path segment the routes know nothing about, so
+ * `/dev/pets/6` on stage `dev` reaches route selection as `pets` then `6`.
+ */
+export declare class SimHttpApiRouteRequest {
+    readonly method: string;
+    readonly segments: readonly string[];
+    constructor(properties: SimHttpApiRouteRequestProperties);
+}
+export {};
+//# sourceMappingURL=sim-http-api-route-request.d.ts.map

package/dist/service/apigatewayv2/api/route/sim-http-api-route-request.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sim-http-api-route-request.d.ts","sourceRoot":"","sources":["../../../../../src/service/apigatewayv2/api/route/sim-http-api-route-request.ts"],"names":[],"mappings":"AAAA,UAAU,gCAAgC;IACxC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,QAAQ,EAAE,SAAS,MAAM,EAAE,CAAC;CACtC;AAED;;;;;;GAMG;AACH,qBAAa,sBAAsB;IACjC,SAAgB,MAAM,EAAE,MAAM,CAAC;IAC/B,SAAgB,QAAQ,EAAE,SAAS,MAAM,EAAE,CAAC;IAE5C,YAAY,UAAU,EAAE,gCAAgC,EAGvD;CACF"}