@opra/common 0.33.13 → 1.0.0-alpha.10

package/cjs/document/factory/http-api.factory.js

@@ -0,0 +1,317 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpApiFactory = void 0;
+const index_js_1 = require("../../helpers/index.js");
+const constants_js_1 = require("../constants.js");
+const http_api_js_1 = require("../http/http-api.js");
+const http_controller_js_1 = require("../http/http-controller.js");
+const http_media_type_js_1 = require("../http/http-media-type.js");
+const http_multipart_field_js_1 = require("../http/http-multipart-field.js");
+const http_operation_js_1 = require("../http/http-operation.js");
+const http_operation_response_js_1 = require("../http/http-operation-response.js");
+const http_parameter_js_1 = require("../http/http-parameter.js");
+const http_request_body_js_1 = require("../http/http-request-body.js");
+const data_type_factory_js_1 = require("./data-type.factory.js");
+/**
+ * @class HttpApiFactory
+ */
+class HttpApiFactory {
+    /**
+     * Generates HttpApi
+     * @param context
+     * @param document
+     * @param init
+     */
+    static async createApi(context, document, init) {
+        const api = new http_api_js_1.HttpApi(document);
+        api.name = init.name;
+        api.description = init.description;
+        api.url = init.url;
+        if (init.controllers) {
+            await context.enterAsync('.controllers', async () => {
+                if (Array.isArray(init.controllers)) {
+                    for (const c of init.controllers) {
+                        const controller = await this._createController(context, api, c);
+                        if (controller)
+                            api.controllers.set(controller.name, controller);
+                    }
+                }
+                else {
+                    for (const [k, v] of Object.entries(init.controllers)) {
+                        const controller = await this._createController(context, api, v, k);
+                        if (controller)
+                            api.controllers.set(controller.name, controller);
+                    }
+                }
+            });
+        }
+        return api;
+    }
+    static async _createController(context, parent, thunk, name) {
+        if (typeof thunk === 'function' && !(0, index_js_1.isConstructor)(thunk)) {
+            thunk = parent instanceof http_controller_js_1.HttpController ? thunk(parent.instance) : thunk();
+        }
+        thunk = await (0, index_js_1.resolveThunk)(thunk);
+        let ctor;
+        let metadata;
+        let instance;
+        // If thunk is a class
+        if (typeof thunk === 'function') {
+            metadata = Reflect.getMetadata(constants_js_1.HTTP_CONTROLLER_METADATA, thunk);
+            if (!metadata)
+                return context.addError(`Class "${thunk.name}" doesn't have a valid HttpController metadata`);
+            ctor = thunk;
+        }
+        else {
+            // If thunk is an instance of a class decorated with HttpController()
+            ctor = Object.getPrototypeOf(thunk).constructor;
+            metadata = Reflect.getMetadata(constants_js_1.HTTP_CONTROLLER_METADATA, ctor);
+            if (metadata)
+                instance = thunk;
+            else {
+                // If thunk is a DecoratorMetadata or InitArguments
+                metadata = thunk;
+                if (thunk.instance === 'object') {
+                    instance = thunk.instance;
+                    ctor = Object.getPrototypeOf(instance).constructor;
+                }
+            }
+        }
+        if (!metadata)
+            return context.addError(`Class "${ctor.name}" is not decorated with HttpController()`);
+        name = name || metadata.name;
+        if (!name)
+            throw new TypeError(`Controller name required`);
+        const controller = new http_controller_js_1.HttpController(parent, {
+            ...metadata,
+            name,
+            instance,
+            ctor,
+        });
+        if (metadata.types) {
+            await context.enterAsync('.types', async () => {
+                await data_type_factory_js_1.DataTypeFactory.addDataTypes(context, controller, metadata.types);
+            });
+        }
+        if (metadata.parameters) {
+            await context.enterAsync('.parameters', async () => {
+                let i = 0;
+                for (const v of metadata.parameters) {
+                    await context.enterAsync(`[${i++}]`, async () => {
+                        const prmArgs = { ...v };
+                        await context.enterAsync('.type', async () => {
+                            if (v.type)
+                                prmArgs.type = controller.node.findDataType(v.type);
+                            if (!prmArgs.type && typeof v.type === 'object') {
+                                prmArgs.type = await data_type_factory_js_1.DataTypeFactory.createDataType(context, controller, v.type);
+                            }
+                            if (!prmArgs.type)
+                                prmArgs.type = controller.node.getDataType('any');
+                        });
+                        const prm = new http_parameter_js_1.HttpParameter(controller, prmArgs);
+                        controller.parameters.push(prm);
+                    });
+                }
+            });
+        }
+        if (metadata.operations) {
+            await context.enterAsync('.operations', async () => {
+                for (const [k, v] of Object.entries(metadata.operations)) {
+                    await context.enterAsync(`[${k}]`, async () => {
+                        const operation = new http_operation_js_1.HttpOperation(controller, { name: k, method: 'GET' });
+                        await this._initHttpOperation(context, operation, v);
+                        controller.operations.set(k, operation);
+                    });
+                }
+            });
+        }
+        if (metadata.controllers) {
+            await context.enterAsync('.controllers', async () => {
+                if (Array.isArray(metadata.controllers)) {
+                    let k = 0;
+                    for (const v of metadata.controllers) {
+                        await context.enterAsync(`[${k}]`, async () => {
+                            const r = await this._createController(context, controller, v);
+                            if (r) {
+                                if (controller.controllers.get(r.name))
+                                    context.addError(`Duplicate controller name (${r.name})`);
+                                controller.controllers.set(r.name, r);
+                            }
+                        });
+                        k++;
+                    }
+                }
+                else {
+                    for (const [k, v] of Object.entries(metadata.controllers)) {
+                        await context.enterAsync(`[${k}]`, async () => {
+                            const r = await this._createController(context, controller, v, k);
+                            if (r) {
+                                if (controller.controllers.get(r.name))
+                                    context.addError(`Duplicate controller name (${r.name})`);
+                                controller.controllers.set(r.name, r);
+                            }
+                        });
+                    }
+                }
+            });
+        }
+        return controller;
+    }
+    /**
+     * Initializes HttpOperation
+     * @param context
+     * @param operation
+     * @param metadata
+     * @protected
+     */
+    static async _initHttpOperation(context, operation, metadata) {
+        const initArgs = {
+            ...metadata,
+            name: operation.name,
+            types: undefined,
+        };
+        http_operation_js_1.HttpOperation.apply(operation, [operation.owner, initArgs]);
+        if (metadata.types) {
+            await context.enterAsync('.types', async () => {
+                await data_type_factory_js_1.DataTypeFactory.addDataTypes(context, operation, metadata.types);
+            });
+        }
+        if (metadata.parameters) {
+            await context.enterAsync('.parameters', async () => {
+                let i = 0;
+                for (const v of metadata.parameters) {
+                    await context.enterAsync(`[${i++}]`, async () => {
+                        const prmArgs = { ...v };
+                        await context.enterAsync('.type', async () => {
+                            if (v.type)
+                                prmArgs.type = operation.node.findDataType(v.type);
+                            if (!prmArgs.type && typeof v.type === 'object') {
+                                prmArgs.type = await data_type_factory_js_1.DataTypeFactory.createDataType(context, operation, v.type);
+                            }
+                            if (!prmArgs.type)
+                                prmArgs.type = operation.node.getDataType('any');
+                        });
+                        const prm = new http_parameter_js_1.HttpParameter(operation, prmArgs);
+                        operation.parameters.push(prm);
+                    });
+                }
+            });
+        }
+        if (metadata.responses) {
+            await context.enterAsync('.responses', async () => {
+                let i = 0;
+                for (const v of metadata.responses) {
+                    await context.enterAsync(`[${i++}]`, async () => {
+                        const response = new http_operation_response_js_1.HttpOperationResponse(operation, { statusCode: v.statusCode });
+                        await this._initHttpOperationResponse(context, response, v);
+                        operation.responses.push(response);
+                    });
+                }
+            });
+        }
+        if (metadata.requestBody) {
+            await context.enterAsync('.requestBody', async () => {
+                const requestBody = new http_request_body_js_1.HttpRequestBody(operation);
+                await this._initHttpRequestBody(context, requestBody, metadata.requestBody);
+                operation.requestBody = requestBody;
+            });
+        }
+        return operation;
+    }
+    /**
+     * Initializes HttpMediaType
+     * @param context
+     * @param target
+     * @param metadata
+     * @protected
+     */
+    static async _initHttpMediaType(context, target, metadata) {
+        http_media_type_js_1.HttpMediaType.call(target, target.owner, {
+            ...metadata,
+            type: undefined,
+            multipartFields: undefined,
+        });
+        if (metadata.type) {
+            await context.enterAsync('.type', async () => {
+                if (metadata.type)
+                    target.type = target.node.findDataType(metadata.type);
+                if (!target.type && (typeof metadata.type === 'object' || typeof metadata.type === 'function')) {
+                    target.type = await data_type_factory_js_1.DataTypeFactory.createDataType(context, target, metadata.type);
+                }
+                if (!target.type)
+                    target.type = target.node.getDataType('any');
+            });
+        }
+        if (metadata.multipartFields) {
+            await context.enterAsync('.multipartFields', async () => {
+                for (let i = 0; i < metadata.multipartFields.length; i++) {
+                    await context.enterAsync(`[${i}]`, async () => {
+                        const src = metadata.multipartFields[i];
+                        const field = new http_multipart_field_js_1.HttpMultipartField(target, { fieldName: src.fieldName, fieldType: src.fieldType });
+                        await this._initHttpMediaType(context, field, src);
+                        target.multipartFields.push(field);
+                    });
+                }
+            });
+        }
+    }
+    /**
+     * Initializes HttpOperationResponse
+     * @param context
+     * @param target
+     * @param metadata
+     * @protected
+     */
+    static async _initHttpOperationResponse(context, target, metadata) {
+        await this._initHttpMediaType(context, target, metadata);
+        target.partial = metadata.partial;
+        if (metadata.parameters) {
+            await context.enterAsync('.parameters', async () => {
+                let i = 0;
+                for (const v of metadata.parameters) {
+                    await context.enterAsync(`[${i++}]`, async () => {
+                        const prmArgs = { ...v };
+                        await context.enterAsync('.type', async () => {
+                            if (v.type)
+                                prmArgs.type = target.node.findDataType(v.type);
+                            if (!prmArgs.type && typeof v.type === 'object') {
+                                prmArgs.type = await data_type_factory_js_1.DataTypeFactory.createDataType(context, target, v.type);
+                            }
+                            if (!prmArgs.type)
+                                prmArgs.type = target.node.getDataType('any');
+                        });
+                        const prm = new http_parameter_js_1.HttpParameter(target, prmArgs);
+                        target.parameters.push(prm);
+                    });
+                }
+            });
+        }
+    }
+    /**
+     * Initializes HttpRequestBody
+     * @param context
+     * @param target
+     * @param metadata
+     * @protected
+     */
+    static async _initHttpRequestBody(context, target, metadata) {
+        target.description = metadata.description;
+        target.required = metadata.required;
+        target.maxContentSize = metadata.maxContentSize;
+        target.immediateFetch = metadata.immediateFetch;
+        target.partial = metadata.partial;
+        if (metadata.content) {
+            await context.enterAsync('.content', async () => {
+                for (let i = 0; i < metadata.content.length; i++) {
+                    await context.enterAsync(`[${i}]`, async () => {
+                        const src = metadata.content[i];
+                        const field = new http_media_type_js_1.HttpMediaType(target, String(i));
+                        await this._initHttpMediaType(context, field, src);
+                        target.content.push(field);
+                    });
+                }
+            });
+        }
+    }
+}
+exports.HttpApiFactory = HttpApiFactory;

package/cjs/document/http/http-api.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpApi = void 0;
+const index_js_1 = require("../../helpers/index.js");
+const api_base_js_1 = require("../common/api-base.js");
+const http_controller_js_1 = require("./http-controller.js");
+/**
+ * @class HttpApi
+ */
+class HttpApi extends api_base_js_1.ApiBase {
+    constructor(owner) {
+        super(owner);
+        this.owner = owner;
+        // noinspection JSUnusedGlobalSymbols
+        this._controllerReverseMap = new WeakMap();
+        this.protocol = 'http';
+        this.controllers = new index_js_1.ResponsiveMap();
+    }
+    findController(arg0) {
+        return http_controller_js_1.HttpController.prototype.findController.call(this, arg0);
+    }
+    findOperation(arg0, operationName) {
+        const controller = this.findController(arg0);
+        return controller?.operations.get(operationName);
+    }
+    toJSON() {
+        const schema = super.toJSON();
+        const out = {
+            ...schema,
+            protocol: this.protocol,
+            url: this.url,
+            controllers: {},
+        };
+        for (const v of this.controllers.values()) {
+            out.controllers[v.name] = v.toJSON();
+        }
+        return out;
+    }
+}
+exports.HttpApi = HttpApi;

package/cjs/document/http/http-controller.js

@@ -0,0 +1,157 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpController = void 0;
+const tslib_1 = require("tslib");
+const node_path_1 = tslib_1.__importDefault(require("node:path"));
+const ts_gems_1 = require("ts-gems");
+const index_js_1 = require("../../helpers/index.js");
+const index_js_2 = require("../../schema/index.js");
+const data_type_map_js_1 = require("../common/data-type-map.js");
+const document_element_js_1 = require("../common/document-element.js");
+const constants_js_1 = require("../constants.js");
+const http_controller_decorator_js_1 = require("../decorators/http-controller.decorator.js");
+const inspect_util_js_1 = require("../utils/inspect.util.js");
+/**
+ * HttpController
+ */
+exports.HttpController = function (...args) {
+    // ClassDecorator
+    if (!this)
+        return exports.HttpController[constants_js_1.DECORATOR].apply(undefined, args);
+    // Constructor
+    const [owner, initArgs] = args;
+    document_element_js_1.DocumentElement.call(this, owner);
+    if (!constants_js_1.CLASS_NAME_PATTERN.test(initArgs.name))
+        throw new TypeError(`Invalid resource name (${initArgs.name})`);
+    const _this = (0, ts_gems_1.asMutable)(this);
+    _this.kind = index_js_2.OpraSchema.HttpController.Kind;
+    _this.types = _this.node[constants_js_1.kDataTypeMap] = new data_type_map_js_1.DataTypeMap();
+    _this.operations = new index_js_1.ResponsiveMap();
+    _this.controllers = new index_js_1.ResponsiveMap();
+    _this.parameters = [];
+    _this.name = initArgs.name;
+    _this.description = initArgs.description;
+    _this.path = initArgs.path || initArgs.name;
+    _this.instance = initArgs.instance;
+    _this.ctor = initArgs.ctor;
+    _this._controllerReverseMap = new WeakMap();
+    _this._initialize?.(initArgs);
+};
+/**
+ *
+ * @class HttpController
+ */
+class HttpControllerClass extends document_element_js_1.DocumentElement {
+    /**
+     * @property isRoot
+     */
+    get isRoot() {
+        return !(this.owner instanceof exports.HttpController);
+    }
+    findController(arg0) {
+        if (typeof arg0 === 'function') {
+            /** Check for cached mapping */
+            let controller = this._controllerReverseMap.get(arg0);
+            if (controller != null)
+                return controller;
+            /** Lookup for ctor in all controllers */
+            for (const c of this.controllers.values()) {
+                if (c.ctor === arg0) {
+                    this._controllerReverseMap.set(arg0, c);
+                    return c;
+                }
+                if (c.controllers.size) {
+                    controller = c.findController(arg0);
+                    if (controller) {
+                        this._controllerReverseMap.set(arg0, controller);
+                        return controller;
+                    }
+                }
+            }
+            this._controllerReverseMap.set(arg0, null);
+            return;
+        }
+        if (arg0.startsWith('/'))
+            arg0 = arg0.substring(1);
+        if (arg0.includes('/')) {
+            const a = arg0.split('/');
+            let r = this;
+            while (r && a.length > 0) {
+                r = r.controllers.get(a.shift());
+            }
+            return r;
+        }
+        return this.controllers.get(arg0);
+    }
+    findParameter(paramName, location) {
+        const paramNameLower = paramName.toLowerCase();
+        let prm;
+        for (prm of this.parameters) {
+            if (location && location !== prm.location)
+                continue;
+            if (typeof prm.name === 'string') {
+                prm._nameLower = prm._nameLower || prm.name.toLowerCase();
+                if (prm._nameLower === paramNameLower)
+                    return prm;
+            }
+            if (prm.name instanceof RegExp && prm.name.test(paramName))
+                return prm;
+        }
+        if (this.node.parent && this.node.parent.element instanceof exports.HttpController) {
+            return this.node.parent.element.findParameter(paramName, location);
+        }
+    }
+    getFullUrl() {
+        return node_path_1.default.posix.join(this.owner instanceof exports.HttpController ? this.owner.getFullUrl() : '/', this.path);
+    }
+    /**
+     *
+     */
+    toString() {
+        return `[HttpController ${this.name}]`;
+    }
+    /**
+     *
+     */
+    toJSON() {
+        const out = (0, index_js_1.omitUndefined)({
+            kind: this.kind,
+            description: this.description,
+            path: this.path,
+        });
+        if (this.operations.size) {
+            out.operations = {};
+            for (const v of this.operations.values()) {
+                out.operations[v.name] = v.toJSON();
+            }
+        }
+        if (this.controllers.size) {
+            out.controllers = {};
+            for (const v of this.controllers.values()) {
+                out.controllers[v.name] = v.toJSON();
+            }
+        }
+        if (this.types.size) {
+            out.types = {};
+            for (const v of this.types.values()) {
+                out.types[v.name] = v.toJSON();
+            }
+        }
+        if (this.parameters.length) {
+            out.parameters = [];
+            for (const prm of this.parameters) {
+                out.parameters.push(prm.toJSON());
+            }
+        }
+        return out;
+    }
+    /**
+     *
+     */
+    [inspect_util_js_1.nodeInspectCustom]() {
+        return `[${inspect_util_js_1.colorFgYellow}HttpController${inspect_util_js_1.colorFgMagenta + this.name + inspect_util_js_1.colorReset}]`;
+    }
+}
+exports.HttpController.prototype = HttpControllerClass.prototype;
+Object.assign(exports.HttpController, http_controller_decorator_js_1.HttpControllerDecoratorFactory);
+exports.HttpController[constants_js_1.DECORATOR] = http_controller_decorator_js_1.HttpControllerDecoratorFactory;

package/cjs/document/http/http-media-type.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpMediaType = void 0;
+const ts_gems_1 = require("ts-gems");
+const index_js_1 = require("../../helpers/index.js");
+const document_element_js_1 = require("../common/document-element.js");
+const data_type_js_1 = require("../data-type/data-type.js");
+exports.HttpMediaType = function (owner, initArgs) {
+    if (!this)
+        throw new TypeError('"this" should be passed to call class constructor');
+    document_element_js_1.DocumentElement.call(this, owner);
+    const _this = (0, ts_gems_1.asMutable)(this);
+    if (initArgs.contentType) {
+        let arr = Array.isArray(initArgs.contentType) ? initArgs.contentType : [initArgs.contentType];
+        arr = arr.map(x => x.split(/\s*,\s*/)).flat();
+        _this.contentType = arr.length > 1 ? arr : arr[0];
+    }
+    _this.description = initArgs.description;
+    _this.contentEncoding = initArgs.contentEncoding;
+    _this.examples = initArgs.examples;
+    _this.multipartFields = [];
+    _this.maxFieldsSize = initArgs.maxFieldsSize;
+    _this.maxFields = initArgs.maxFields;
+    _this.maxFiles = initArgs.maxFiles;
+    _this.maxFileSize = initArgs.maxFileSize;
+    _this.maxTotalFileSize = initArgs.maxTotalFileSize;
+    _this.minFileSize = initArgs.minFileSize;
+    if (initArgs?.type) {
+        _this.type = initArgs?.type instanceof data_type_js_1.DataType ? initArgs.type : _this.owner.node.getDataType(initArgs.type);
+    }
+    _this.isArray = initArgs.isArray;
+};
+/**
+ * @class HttpMediaType
+ */
+class HttpMediaTypeClass extends document_element_js_1.DocumentElement {
+    findMultipartField(fieldName, fieldType) {
+        if (!this.multipartFields)
+            return;
+        for (const f of this.multipartFields) {
+            if ((!fieldType || fieldType === f.fieldType) &&
+                ((f.fieldName instanceof RegExp && f.fieldName.test(fieldName)) || f.fieldName === fieldName)) {
+                return f;
+            }
+        }
+    }
+    toJSON() {
+        const typeName = this.type ? this.node.getDataTypeNameWithNs(this.type) : undefined;
+        const out = (0, index_js_1.omitUndefined)({
+            description: this.description,
+            contentType: this.contentType,
+            contentEncoding: this.contentEncoding,
+            type: typeName ? typeName : this.type?.toJSON(),
+            isArray: this.isArray,
+            example: this.example,
+            examples: this.examples,
+            maxFields: this.maxFields,
+            maxFieldsSize: this.maxFieldsSize,
+            maxFiles: this.maxFiles,
+            maxFileSize: this.maxFileSize,
+            maxTotalFileSize: this.maxTotalFileSize,
+            minFileSize: this.minFileSize,
+        });
+        if (this.multipartFields?.length) {
+            out.multipartFields = this.multipartFields.map(x => x.toJSON());
+        }
+        return out;
+    }
+}
+exports.HttpMediaType.prototype = HttpMediaTypeClass.prototype;

package/cjs/document/http/http-multipart-field.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpMultipartField = void 0;
+const index_js_1 = require("../../helpers/index.js");
+const parse_regexp_util_js_1 = require("../utils/parse-regexp.util.js");
+const http_media_type_js_1 = require("./http-media-type.js");
+/**
+ *
+ * @class HttpMultipartField
+ */
+class HttpMultipartField extends http_media_type_js_1.HttpMediaType {
+    constructor(owner, initArgs) {
+        super(owner, initArgs);
+        this.owner = owner;
+        this.fieldName =
+            initArgs.fieldName instanceof RegExp
+                ? initArgs.fieldName
+                : initArgs.fieldName.startsWith('/')
+                    ? (0, parse_regexp_util_js_1.parseRegExp)(initArgs.fieldName)
+                    : initArgs.fieldName;
+        this.fieldType = initArgs.fieldType;
+        this.required = initArgs.required;
+    }
+    toJSON() {
+        return (0, index_js_1.omitUndefined)({
+            fieldName: this.fieldName,
+            fieldType: this.fieldType,
+            required: this.required,
+            ...super.toJSON(),
+        });
+    }
+}
+exports.HttpMultipartField = HttpMultipartField;

package/cjs/document/http/http-operation-response.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpOperationResponse = void 0;
+const index_js_1 = require("../../helpers/index.js");
+const http_media_type_js_1 = require("./http-media-type.js");
+const http_status_range_js_1 = require("./http-status-range.js");
+/**
+ * @class HttpOperationResponse
+ */
+class HttpOperationResponse extends http_media_type_js_1.HttpMediaType {
+    constructor(owner, init) {
+        super(owner, init);
+        this.owner = owner;
+        this.parameters = [];
+        this.statusCode = (Array.isArray(init.statusCode) ? init.statusCode : [init.statusCode]).map(x => typeof x === 'object' ? new http_status_range_js_1.HttpStatusRange(x.start, x.end) : new http_status_range_js_1.HttpStatusRange(x));
+        this.partial = init.partial;
+    }
+    findParameter(paramName, location) {
+        paramName = paramName.toLowerCase();
+        for (const prm of this.parameters) {
+            if ((!location || location === prm.location) &&
+                ((prm.name instanceof RegExp && prm.name.test(paramName)) || prm.name === paramName)) {
+                return prm;
+            }
+        }
+    }
+    toJSON() {
+        const statusCode = this.statusCode.map(x => x.toJSON());
+        const out = (0, index_js_1.omitUndefined)({
+            ...super.toJSON(),
+            statusCode: statusCode.length === 1 && typeof statusCode[0] === 'number' ? statusCode[0] : statusCode,
+            partial: this.partial,
+        });
+        if (this.parameters.length) {
+            out.parameters = [];
+            for (const prm of this.parameters) {
+                out.parameters.push(prm.toJSON());
+            }
+        }
+        return out;
+    }
+}
+exports.HttpOperationResponse = HttpOperationResponse;