@epsilon-asi/foundation 0.0.1-rc3 → 0.0.2

package/build/decorators/requests/mapping.d.ts

@@ -0,0 +1,234 @@
+import type { ClassDecoratorDefinition, Constructor, DecorationRecord, DecoratorRegistry, DecoratorSchema, PropertyDecoratorDefinition } from '../factory';
+export type RequestSection = 'params' | 'body' | 'query' | 'headers';
+export type AutoMapSection = 'param' | 'body' | 'query' | 'header';
+export type DataType = 'string' | 'number' | 'boolean' | 'date';
+export type RequestPrimitive = string | number | boolean | Date;
+export interface RequestContents<Body extends Record<string, unknown> | undefined = Record<string, unknown>, Query extends Record<string, unknown> | undefined = Record<string, unknown>, Params extends Record<string, unknown> | undefined = Record<string, unknown>, Headers extends Record<string, unknown> | undefined = Record<string, unknown>> {
+    body?: Body;
+    query?: Query;
+    params?: Params;
+    headers?: Headers;
+}
+export interface RequestObjectMetadata {
+    description?: string;
+}
+export interface RequestFieldBaseMetadata {
+    section: RequestSection;
+    /**
+     * Source key inside request.params/request.body/request.query/request.headers.
+     * Defaults to the decorated property name.
+     */
+    name?: string;
+    required?: boolean;
+    description?: string;
+}
+export interface StringRequestFieldMetadata extends RequestFieldBaseMetadata {
+    type: 'string';
+    default?: string;
+}
+export interface NumberRequestFieldMetadata extends RequestFieldBaseMetadata {
+    type: 'number';
+    default?: number;
+    integer?: boolean;
+    min?: number;
+    max?: number;
+}
+export interface BooleanRequestFieldMetadata extends RequestFieldBaseMetadata {
+    type: 'boolean';
+    default?: boolean;
+}
+export interface DateRequestFieldMetadata extends RequestFieldBaseMetadata {
+    type: 'date';
+    default?: Date;
+}
+export interface UnknownRequestFieldMetadata extends RequestFieldBaseMetadata {
+    type?: undefined;
+    default?: unknown;
+}
+export type RequestFieldMetadata = StringRequestFieldMetadata | NumberRequestFieldMetadata | BooleanRequestFieldMetadata | DateRequestFieldMetadata | UnknownRequestFieldMetadata;
+export type AutoMapOpts = {
+    /** Exactly one of these should be true. */
+    param?: boolean;
+    body?: boolean;
+    query?: boolean;
+    header?: boolean;
+    name?: string;
+    key?: string;
+    type?: DataType;
+    required?: boolean;
+    default?: unknown;
+    description?: string;
+};
+export interface RequestMappingSchema extends DecoratorSchema {
+    class: {
+        requestObject: ClassDecoratorDefinition<RequestObjectMetadata | undefined>;
+    };
+    property: {
+        requestField: PropertyDecoratorDefinition<RequestFieldMetadata, unknown>;
+    };
+    method: {};
+    accessor: {};
+}
+export type FieldDecoratorFor<TValue> = <TThis, TActual extends TValue | undefined>(value: undefined, context: ClassFieldDecoratorContext<TThis, TActual>) => void;
+export type AnyFieldDecorator = <TThis, TActual>(value: undefined, context: ClassFieldDecoratorContext<TThis, TActual>) => void;
+export type StringFieldOptions = Omit<StringRequestFieldMetadata, 'section' | 'type'>;
+export type NumberFieldOptions = Omit<NumberRequestFieldMetadata, 'section' | 'type'>;
+export type BooleanFieldOptions = Omit<BooleanRequestFieldMetadata, 'section' | 'type'>;
+export type DateFieldOptions = Omit<DateRequestFieldMetadata, 'section' | 'type'>;
+export type UnknownFieldOptions = Omit<UnknownRequestFieldMetadata, 'section' | 'type'>;
+export interface RequestSectionDecorator<TDefaultValue> {
+    (): FieldDecoratorFor<TDefaultValue>;
+    (name: string): FieldDecoratorFor<TDefaultValue>;
+    (options: StringFieldOptions & {
+        type: 'string';
+    }): FieldDecoratorFor<string>;
+    (options: NumberFieldOptions & {
+        type: 'number';
+    }): FieldDecoratorFor<number>;
+    (options: BooleanFieldOptions & {
+        type: 'boolean';
+    }): FieldDecoratorFor<boolean>;
+    (options: DateFieldOptions & {
+        type: 'date';
+    }): FieldDecoratorFor<Date>;
+    (options: UnknownFieldOptions): FieldDecoratorFor<TDefaultValue>;
+    (name: string, options: StringFieldOptions & {
+        type: 'string';
+    }): FieldDecoratorFor<string>;
+    (name: string, options: NumberFieldOptions & {
+        type: 'number';
+    }): FieldDecoratorFor<number>;
+    (name: string, options: BooleanFieldOptions & {
+        type: 'boolean';
+    }): FieldDecoratorFor<boolean>;
+    (name: string, options: DateFieldOptions & {
+        type: 'date';
+    }): FieldDecoratorFor<Date>;
+    (name: string, options: UnknownFieldOptions): FieldDecoratorFor<TDefaultValue>;
+    string(name?: string, options?: StringFieldOptions): FieldDecoratorFor<string>;
+    number(name?: string, options?: NumberFieldOptions): FieldDecoratorFor<number>;
+    boolean(name?: string, options?: BooleanFieldOptions): FieldDecoratorFor<boolean>;
+    date(name?: string, options?: DateFieldOptions): FieldDecoratorFor<Date>;
+}
+export interface RequestMappingDefinition {
+    propertyName: string;
+    sourceKey: string;
+    section: RequestSection;
+    type?: DataType;
+    required: boolean;
+    static: boolean;
+    private: boolean;
+    metadata: RequestFieldMetadata;
+    record: DecorationRecord;
+}
+export interface LegacyMetaEntry {
+    key: string;
+    sourceKey: string;
+    dataType?: DataType;
+    required?: boolean;
+}
+export interface LegacyMetaContainer {
+    params: Record<string, LegacyMetaEntry>;
+    body: Record<string, LegacyMetaEntry>;
+    query: Record<string, LegacyMetaEntry>;
+    headers: Record<string, LegacyMetaEntry>;
+}
+export interface RequestMapperOptions {
+    namespace?: string;
+    allowPrivateMembers?: boolean;
+}
+export interface RequestReadOptions {
+    includeInherited?: boolean;
+}
+export interface AssignRequestOptions extends RequestReadOptions {
+    /**
+     * If true, throws when @Param/@Body/@Query/@Header is applied to a static field.
+     * Defaults to true because request objects are normally instance DTOs.
+     */
+    rejectStatic?: boolean;
+}
+export interface ToRequestContentsOptions extends RequestReadOptions {
+    includeUndefined?: boolean;
+    /**
+     * By default values are preserved. Use 'http' to stringify params/query/headers.
+     */
+    serialize?: 'preserve' | 'http';
+    rejectStatic?: boolean;
+}
+export declare class RequestMappingError extends Error {
+    readonly section?: RequestSection;
+    readonly propertyName?: string;
+    readonly sourceKey?: string;
+    constructor(message: string, details?: {
+        section?: RequestSection;
+        propertyName?: string;
+        sourceKey?: string;
+    });
+}
+type ConcreteConstructor<T> = new (...args: never[]) => T;
+type RequestMapperApi = {
+    registry: DecoratorRegistry<RequestMappingSchema>;
+    RequestObject(metadata?: RequestObjectMetadata): <TClass extends Constructor>(value: TClass, context: ClassDecoratorContext<TClass>) => void;
+    AutoMap(opts: AutoMapOpts & {
+        type: 'string';
+    }): FieldDecoratorFor<string>;
+    AutoMap(opts: AutoMapOpts & {
+        type: 'number';
+    }): FieldDecoratorFor<number>;
+    AutoMap(opts: AutoMapOpts & {
+        type: 'boolean';
+    }): FieldDecoratorFor<boolean>;
+    AutoMap(opts: AutoMapOpts & {
+        type: 'date';
+    }): FieldDecoratorFor<Date>;
+    AutoMap(opts: AutoMapOpts): AnyFieldDecorator;
+    Param: RequestSectionDecorator<string>;
+    Query: RequestSectionDecorator<string>;
+    Header: RequestSectionDecorator<string>;
+    Body: RequestSectionDecorator<unknown>;
+    getRequestMappingDefinitions(target: Constructor | object, options?: RequestReadOptions): readonly RequestMappingDefinition[];
+    getAutoMapMeta(target: Constructor | object, options?: RequestReadOptions): LegacyMetaContainer;
+    assignRequestContents<T extends object>(target: T, request: RequestContents, options?: AssignRequestOptions): T;
+    requestContentsToObject<T extends object>(ctor: ConcreteConstructor<T>, request: RequestContents, options?: AssignRequestOptions): T;
+    objectToRequestContents<T extends object>(source: T, options?: ToRequestContentsOptions): RequestContents;
+};
+export declare function createRequestMapper(options?: RequestMapperOptions): RequestMapperApi;
+export declare const requestMappingRegistry: DecoratorRegistry<RequestMappingSchema>;
+export declare const RequestObject: (metadata?: RequestObjectMetadata) => <TClass extends Constructor>(value: TClass, context: ClassDecoratorContext<TClass>) => void;
+export declare const AutoMap: {
+    (opts: AutoMapOpts & {
+        type: "string";
+    }): FieldDecoratorFor<string>;
+    (opts: AutoMapOpts & {
+        type: "number";
+    }): FieldDecoratorFor<number>;
+    (opts: AutoMapOpts & {
+        type: "boolean";
+    }): FieldDecoratorFor<boolean>;
+    (opts: AutoMapOpts & {
+        type: "date";
+    }): FieldDecoratorFor<Date>;
+    (opts: AutoMapOpts): AnyFieldDecorator;
+};
+export declare const Param: RequestSectionDecorator<string>;
+export declare const Query: RequestSectionDecorator<string>;
+export declare const Header: RequestSectionDecorator<string>;
+export declare const Body: RequestSectionDecorator<unknown>;
+export declare const getRequestMappingDefinitions: (target: Constructor | object, options?: RequestReadOptions) => readonly RequestMappingDefinition[];
+export declare const getAutoMapMeta: (target: Constructor | object, options?: RequestReadOptions) => LegacyMetaContainer;
+export declare const assignRequestContents: <T extends object>(target: T, request: RequestContents, options?: AssignRequestOptions) => T;
+export declare const requestContentsToObject: <T extends object>(ctor: ConcreteConstructor<T>, request: RequestContents, options?: AssignRequestOptions) => T;
+export declare const objectToRequestContents: <T extends object>(source: T, options?: ToRequestContentsOptions) => RequestContents;
+export declare class MappedRequest<TRequest extends RequestContents = RequestContents> {
+    defaultConstruct(request: TRequest): void;
+    construct(_request: TRequest): void;
+    destruct(options?: ToRequestContentsOptions): TRequest;
+    toRequestContents(options?: ToRequestContentsOptions): TRequest;
+    validateWith<TError>(validate: (value: this) => readonly TError[] | Promise<readonly TError[]>): Promise<readonly TError[]>;
+    constructor(request?: TRequest);
+    static create<T extends object>(this: ConcreteConstructor<T>, data: Partial<CleanRequestObject<T>>): T;
+    static fromRequest<T extends object>(this: ConcreteConstructor<T>, request: RequestContents, options?: AssignRequestOptions): T;
+}
+export type CleanRequestObject<T> = Omit<T, 'defaultConstruct' | 'construct' | 'destruct' | 'toRequestContents' | 'validateWith'>;
+export declare function CleanRequestObject<T extends object>(request: T): CleanRequestObject<T>;
+export default MappedRequest;

package/build/decorators/requests/mapping.js

@@ -0,0 +1,460 @@
+"use strict";
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MappedRequest = exports.objectToRequestContents = exports.requestContentsToObject = exports.assignRequestContents = exports.getAutoMapMeta = exports.getRequestMappingDefinitions = exports.Body = exports.Header = exports.Query = exports.Param = exports.AutoMap = exports.RequestObject = exports.requestMappingRegistry = exports.RequestMappingError = void 0;
+exports.createRequestMapper = createRequestMapper;
+exports.CleanRequestObject = CleanRequestObject;
+const factory_1 = require("../factory");
+class RequestMappingError extends Error {
+    constructor(message, details = {}) {
+        super(message);
+        this.name = 'RequestMappingError';
+        this.section = details.section;
+        this.propertyName = details.propertyName;
+        this.sourceKey = details.sourceKey;
+    }
+}
+exports.RequestMappingError = RequestMappingError;
+const pendingRequestSymbol = Symbol('requestMapping.pendingRequest');
+function setPendingRequest(target, request) {
+    Object.defineProperty(target, pendingRequestSymbol, {
+        configurable: true,
+        enumerable: false,
+        writable: true,
+        value: request,
+    });
+}
+function getPendingRequest(target) {
+    return target[pendingRequestSymbol];
+}
+function createRequestMapper(options = {}) {
+    var _a, _b;
+    const registry = (0, factory_1.createDecoratorRegistry)({
+        namespace: (_a = options.namespace) !== null && _a !== void 0 ? _a : 'request-mapping',
+        allowPrivateMembers: (_b = options.allowPrivateMembers) !== null && _b !== void 0 ? _b : false,
+    });
+    const RequestObject = registry.class('requestObject');
+    const Scoped = registry.for();
+    const RawRequestField = Scoped.property('requestField');
+    function makeFieldDecorator(metadata) {
+        const recordDecorator = RawRequestField(metadata);
+        return function requestFieldDecorator(value, context) {
+            var _a;
+            recordDecorator(value, context);
+            if (context.static || typeof context.name !== 'string') {
+                return undefined;
+            }
+            const propertyName = context.name;
+            const sourceKey = (_a = metadata.name) !== null && _a !== void 0 ? _a : propertyName;
+            return function requestFieldInitializer(initialValue) {
+                var _a;
+                if (typeof this !== 'object' || this === null)
+                    return initialValue;
+                const request = getPendingRequest(this);
+                if (request === undefined)
+                    return initialValue;
+                const definition = createInitializerDefinition({
+                    propertyName,
+                    sourceKey,
+                    metadata,
+                    static: context.static,
+                    private: context.private,
+                });
+                const rawValue = (_a = getSectionSource(request, metadata.section)) === null || _a === void 0 ? void 0 : _a[sourceKey];
+                return coerceRequestValue(rawValue, definition);
+            };
+        };
+    }
+    function AutoMap(opts) {
+        var _a;
+        const section = sectionFromAutoMapOptions(opts);
+        const metadata = normalizeMetadata(section, undefined, (_a = opts.name) !== null && _a !== void 0 ? _a : opts.key, opts);
+        return makeFieldDecorator(metadata);
+    }
+    const Param = createSectionDecorator('params', 'string', makeFieldDecorator);
+    const Query = createSectionDecorator('query', 'string', makeFieldDecorator);
+    const Header = createSectionDecorator('headers', 'string', makeFieldDecorator);
+    const Body = createSectionDecorator('body', undefined, makeFieldDecorator);
+    function getRequestMappingDefinitions(target, readOptions = {}) {
+        const snapshot = registry.read(target, {
+            includeInherited: readOptions.includeInherited,
+        });
+        return Object.freeze(snapshot.propertyRecords('requestField').map((record) => {
+            var _a, _b;
+            if (record.memberName === undefined) {
+                throw new RequestMappingError('Request mapping record is missing memberName.');
+            }
+            if (typeof record.memberName === 'symbol') {
+                throw new RequestMappingError(`Request mapping does not support symbol member keys: ${String(record.memberName)}.`);
+            }
+            const metadata = record.metadata;
+            const propertyName = record.memberName;
+            const sourceKey = (_a = metadata.name) !== null && _a !== void 0 ? _a : propertyName;
+            return Object.freeze({
+                propertyName,
+                sourceKey,
+                section: metadata.section,
+                type: metadata.type,
+                required: (_b = metadata.required) !== null && _b !== void 0 ? _b : false,
+                static: record.static,
+                private: record.private,
+                metadata,
+                record,
+            });
+        }));
+    }
+    function getAutoMapMeta(target, readOptions = {}) {
+        const result = {
+            params: {},
+            body: {},
+            query: {},
+            headers: {},
+        };
+        for (const definition of getRequestMappingDefinitions(target, readOptions)) {
+            const entry = {
+                key: definition.propertyName,
+                sourceKey: definition.sourceKey,
+                dataType: definition.type,
+                required: definition.required,
+            };
+            result[definition.section][definition.propertyName] = entry;
+        }
+        return result;
+    }
+    function assignRequestContents(target, request, assignOptions = {}) {
+        var _a;
+        const rejectStatic = (_a = assignOptions.rejectStatic) !== null && _a !== void 0 ? _a : true;
+        for (const definition of getRequestMappingDefinitions(target, assignOptions)) {
+            assertUsableDefinition(definition, rejectStatic);
+            const sectionSource = getSectionSource(request, definition.section);
+            const rawValue = sectionSource === null || sectionSource === void 0 ? void 0 : sectionSource[definition.sourceKey];
+            const value = coerceRequestValue(rawValue, definition);
+            setObjectProperty(target, definition.propertyName, value);
+        }
+        return target;
+    }
+    function requestContentsToObject(ctor, request, assignOptions = {}) {
+        const instance = new ctor();
+        return assignRequestContents(instance, request, assignOptions);
+    }
+    function objectToRequestContents(source, toOptions = {}) {
+        var _a, _b, _c;
+        const rejectStatic = (_a = toOptions.rejectStatic) !== null && _a !== void 0 ? _a : true;
+        const includeUndefined = (_b = toOptions.includeUndefined) !== null && _b !== void 0 ? _b : true;
+        const serialize = (_c = toOptions.serialize) !== null && _c !== void 0 ? _c : 'preserve';
+        const out = {
+            params: {},
+            body: {},
+            query: {},
+            headers: {},
+        };
+        for (const definition of getRequestMappingDefinitions(source, toOptions)) {
+            assertUsableDefinition(definition, rejectStatic);
+            const value = getObjectProperty(source, definition.propertyName);
+            if (value === undefined && !includeUndefined)
+                continue;
+            const section = ensureSection(out, definition.section);
+            section[definition.sourceKey] = serializeValueForRequest(value, definition, serialize);
+        }
+        return out;
+    }
+    return Object.freeze({
+        registry,
+        RequestObject,
+        AutoMap: AutoMap,
+        Param,
+        Query,
+        Header,
+        Body,
+        getRequestMappingDefinitions,
+        getAutoMapMeta,
+        assignRequestContents,
+        requestContentsToObject,
+        objectToRequestContents,
+    });
+}
+function createSectionDecorator(section, defaultType, makeFieldDecorator) {
+    const decorator = ((first, second) => {
+        const metadata = normalizeSectionDecoratorMetadata(section, defaultType, first, second);
+        return makeFieldDecorator(metadata);
+    });
+    decorator.string = (name, options = {}) => makeFieldDecorator(normalizeMetadata(section, 'string', name, options));
+    decorator.number = (name, options = {}) => makeFieldDecorator(normalizeMetadata(section, 'number', name, options));
+    decorator.boolean = (name, options = {}) => makeFieldDecorator(normalizeMetadata(section, 'boolean', name, options));
+    decorator.date = (name, options = {}) => makeFieldDecorator(normalizeMetadata(section, 'date', name, options));
+    return decorator;
+}
+function normalizeSectionDecoratorMetadata(section, defaultType, first, second) {
+    if (typeof first === 'string') {
+        return normalizeMetadata(section, defaultType, first, second !== null && second !== void 0 ? second : {});
+    }
+    return normalizeMetadata(section, defaultType, first === null || first === void 0 ? void 0 : first.name, first !== null && first !== void 0 ? first : {});
+}
+function normalizeMetadata(section, defaultType, explicitName, options) {
+    const _a = (options !== null && options !== void 0 ? options : {}), { name: _name, key: _key, param: _param, body: _body, query: _query, header: _header, type: optionType } = _a, rest = __rest(_a, ["name", "key", "param", "body", "query", "header", "type"]);
+    return Object.assign(Object.assign({}, rest), { section, name: explicitName, type: optionType !== null && optionType !== void 0 ? optionType : defaultType });
+}
+function sectionFromAutoMapOptions(opts) {
+    const sections = [];
+    if (opts.param)
+        sections.push('params');
+    if (opts.body)
+        sections.push('body');
+    if (opts.query)
+        sections.push('query');
+    if (opts.header)
+        sections.push('headers');
+    if (sections.length !== 1) {
+        throw new RequestMappingError('@AutoMap requires exactly one of { param, body, query, header }.');
+    }
+    return sections[0];
+}
+function createInitializerDefinition(args) {
+    var _a;
+    return {
+        propertyName: args.propertyName,
+        sourceKey: args.sourceKey,
+        section: args.metadata.section,
+        type: args.metadata.type,
+        required: (_a = args.metadata.required) !== null && _a !== void 0 ? _a : false,
+        static: args.static,
+        private: args.private,
+        metadata: args.metadata,
+        record: undefined,
+    };
+}
+function assertUsableDefinition(definition, rejectStatic) {
+    if (definition.private) {
+        throw new RequestMappingError(`Request mapping field "${definition.propertyName}" cannot be private.`, definition);
+    }
+    if (rejectStatic && definition.static) {
+        throw new RequestMappingError(`Request mapping field "${definition.propertyName}" must be an instance field, not static.`, definition);
+    }
+}
+function getSectionSource(request, section) {
+    return request[section];
+}
+function ensureSection(request, section) {
+    const existing = request[section];
+    if (existing !== undefined)
+        return existing;
+    const created = {};
+    request[section] = created;
+    return created;
+}
+function coerceRequestValue(rawValue, definition) {
+    const metadata = definition.metadata;
+    const missing = rawValue === undefined || rawValue === null;
+    if (missing) {
+        if (Object.prototype.hasOwnProperty.call(metadata, 'default')) {
+            return cloneSimpleDefault(metadata.default);
+        }
+        if (definition.required) {
+            throw new RequestMappingError(`Missing required ${definition.section} value "${definition.sourceKey}" for property "${definition.propertyName}".`, definition);
+        }
+        return undefined;
+    }
+    switch (metadata.type) {
+        case undefined:
+            return rawValue;
+        case 'string':
+            return coerceString(rawValue);
+        case 'number':
+            return coerceNumber(rawValue, definition);
+        case 'boolean':
+            return coerceBoolean(rawValue, definition);
+        case 'date':
+            return coerceDate(rawValue, definition);
+        default:
+            return assertNever(metadata);
+    }
+}
+function coerceString(value) {
+    if (typeof value === 'string')
+        return value;
+    if (value instanceof Date)
+        return value.toISOString();
+    return String(value);
+}
+function coerceNumber(value, definition) {
+    if (typeof value === 'number') {
+        validateNumber(value, definition);
+        return value;
+    }
+    if (typeof value === 'boolean') {
+        const numberValue = value ? 1 : 0;
+        validateNumber(numberValue, definition);
+        return numberValue;
+    }
+    if (typeof value !== 'string' || value.trim() === '') {
+        throw new RequestMappingError(`Expected ${definition.section} value "${definition.sourceKey}" to be a number-compatible value.`, definition);
+    }
+    const numberValue = Number(value);
+    validateNumber(numberValue, definition);
+    return numberValue;
+}
+function validateNumber(value, definition) {
+    const metadata = definition.metadata;
+    if (!Number.isFinite(value)) {
+        throw new RequestMappingError(`Expected ${definition.section} value "${definition.sourceKey}" to be a finite number.`, definition);
+    }
+    if (metadata.integer === true && !Number.isInteger(value)) {
+        throw new RequestMappingError(`Expected ${definition.section} value "${definition.sourceKey}" to be an integer.`, definition);
+    }
+    if (metadata.min !== undefined && value < metadata.min) {
+        throw new RequestMappingError(`Expected ${definition.section} value "${definition.sourceKey}" to be >= ${metadata.min}.`, definition);
+    }
+    if (metadata.max !== undefined && value > metadata.max) {
+        throw new RequestMappingError(`Expected ${definition.section} value "${definition.sourceKey}" to be <= ${metadata.max}.`, definition);
+    }
+}
+function coerceBoolean(value, definition) {
+    if (typeof value === 'boolean')
+        return value;
+    if (typeof value === 'number') {
+        if (value === 1)
+            return true;
+        if (value === 0)
+            return false;
+    }
+    if (typeof value === 'string') {
+        const normalized = value.trim().toLowerCase();
+        if (['true', '1', 'yes', 'y', 'on'].includes(normalized))
+            return true;
+        if (['false', '0', 'no', 'n', 'off'].includes(normalized))
+            return false;
+    }
+    throw new RequestMappingError(`Expected ${definition.section} value "${definition.sourceKey}" to be boolean-compatible.`, definition);
+}
+function coerceDate(value, definition) {
+    if (value instanceof Date) {
+        assertValidDate(value, definition);
+        return value;
+    }
+    let date;
+    if (typeof value === 'number') {
+        date = new Date(value);
+    }
+    else if (typeof value === 'string') {
+        const trimmed = value.trim();
+        const numeric = trimmed !== '' ? Number(trimmed) : Number.NaN;
+        date = Number.isFinite(numeric) ? new Date(numeric) : new Date(trimmed);
+    }
+    else {
+        throw new RequestMappingError(`Expected ${definition.section} value "${definition.sourceKey}" to be date-compatible.`, definition);
+    }
+    assertValidDate(date, definition);
+    return date;
+}
+function assertValidDate(value, definition) {
+    if (Number.isNaN(value.getTime())) {
+        throw new RequestMappingError(`Expected ${definition.section} value "${definition.sourceKey}" to be a valid date.`, definition);
+    }
+}
+function serializeValueForRequest(value, definition, mode) {
+    if (mode === 'preserve')
+        return value;
+    if (value === undefined || value === null)
+        return value;
+    if (definition.section === 'body') {
+        return value;
+    }
+    if (value instanceof Date) {
+        return value.toISOString();
+    }
+    return String(value);
+}
+function setObjectProperty(target, propertyName, value) {
+    target[propertyName] = value;
+}
+function getObjectProperty(target, propertyName) {
+    return target[propertyName];
+}
+function cloneSimpleDefault(value) {
+    if (value instanceof Date)
+        return new Date(value.getTime());
+    if (Array.isArray(value))
+        return value.slice();
+    if (isPlainObject(value))
+        return Object.assign({}, value);
+    return value;
+}
+function isPlainObject(value) {
+    return typeof value === 'object'
+        && value !== null
+        && Object.getPrototypeOf(value) === Object.prototype;
+}
+function assertNever(value) {
+    throw new RequestMappingError(`Unsupported request mapping metadata: ${JSON.stringify(value)}.`);
+}
+const defaultMapper = createRequestMapper();
+exports.requestMappingRegistry = defaultMapper.registry;
+exports.RequestObject = defaultMapper.RequestObject;
+exports.AutoMap = defaultMapper.AutoMap;
+exports.Param = defaultMapper.Param;
+exports.Query = defaultMapper.Query;
+exports.Header = defaultMapper.Header;
+exports.Body = defaultMapper.Body;
+exports.getRequestMappingDefinitions = defaultMapper.getRequestMappingDefinitions;
+exports.getAutoMapMeta = defaultMapper.getAutoMapMeta;
+exports.assignRequestContents = defaultMapper.assignRequestContents;
+exports.requestContentsToObject = defaultMapper.requestContentsToObject;
+exports.objectToRequestContents = defaultMapper.objectToRequestContents;
+class MappedRequest {
+    defaultConstruct(request) {
+        (0, exports.assignRequestContents)(this, request);
+    }
+    construct(_request) {
+        // Extension hook for subclasses.
+    }
+    destruct(options) {
+        return (0, exports.objectToRequestContents)(this, options);
+    }
+    toRequestContents(options) {
+        return this.destruct(options);
+    }
+    validateWith(validate) {
+        return Promise.resolve(validate(this));
+    }
+    constructor(request) {
+        if (request !== undefined) {
+            setPendingRequest(this, request);
+        }
+    }
+    static create(data) {
+        const instance = new this();
+        for (const key of Object.keys(data)) {
+            instance[key] = data[key];
+        }
+        return instance;
+    }
+    static fromRequest(request, options) {
+        const instance = new this();
+        (0, exports.assignRequestContents)(instance, request, options);
+        const maybeConstruct = instance.construct;
+        if (typeof maybeConstruct === 'function')
+            maybeConstruct.call(instance, request);
+        return instance;
+    }
+}
+exports.MappedRequest = MappedRequest;
+function CleanRequestObject(request) {
+    const out = {};
+    for (const key of Object.keys(request)) {
+        const value = request[key];
+        if (typeof value !== 'function')
+            out[key] = value;
+    }
+    return out;
+}
+exports.default = MappedRequest;