@valkyrjaio/valkyrja 26.0.0

package/src/Valkyrja/Http/Message/Header/Value/Value.ts

@@ -0,0 +1,56 @@
+/*
+ * This file is part of the Valkyrja package.
+ *
+ * (c) Melech Mizrachi <melechmizrachi@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+import type { ComponentContract } from './Component/Contract/ComponentContract.js';
+import type { ValueContract } from './Contract/ValueContract.js';
+import { ObjectFactory } from '../../../../Type/Object/Factory/ObjectFactory.js';
+
+export class Value implements ValueContract {
+    protected components: Array<ComponentContract | string>;
+
+    constructor(...components: Array<ComponentContract | string>) {
+        this.components = this.filterComponents(...components);
+    }
+
+    static fromValue(value: string): Value {
+        const deliminator = ';';
+        const parts = value.includes(deliminator) ? value.split(deliminator) : [value];
+        return new Value(...parts.map((p) => p.trim()));
+    }
+
+    getComponents(): Array<ComponentContract | string> {
+        return this.components;
+    }
+
+    withComponents(...components: Array<ComponentContract | string>): this {
+        const clone = ObjectFactory.clone(this);
+        clone.components = this.filterComponents(...components);
+        return clone;
+    }
+
+    withAddedComponents(...components: Array<ComponentContract | string>): this {
+        const clone = this.withComponents(...components);
+        clone.components = [...this.components, ...clone.components];
+        return clone;
+    }
+
+    toString(): string {
+        return this.components
+            .map((c) => (typeof c === 'string' ? c : c.toString()).trim())
+            .filter((s) => s !== '')
+            .join('; ');
+    }
+
+    protected filterComponents(...components: Array<ComponentContract | string>): Array<ComponentContract | string> {
+        return components.filter((c) => {
+            const str = typeof c === 'string' ? c : c.toString();
+            return str !== '';
+        });
+    }
+}

package/src/Valkyrja/Http/Message/Param/Abstract/ParamCollection.ts

@@ -0,0 +1,63 @@
+/*
+ * This file is part of the Valkyrja package.
+ *
+ * (c) Melech Mizrachi <melechmizrachi@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+import type { ParamCollectionContract } from '../Contract/ParamCollectionContract.js';
+import { ObjectFactory } from '../../../../Type/Object/Factory/ObjectFactory.js';
+
+export abstract class ParamCollection<V = unknown> implements ParamCollectionContract<V> {
+    protected params: Record<string, V>;
+
+    constructor(params: Record<string, V> = {}) {
+        this.params = params;
+    }
+
+    has(key: string): boolean {
+        return key in this.params;
+    }
+
+    get(key: string): V | undefined {
+        return this.params[key];
+    }
+
+    getAll(): Record<string, V> {
+        return { ...this.params };
+    }
+
+    getOnly(...keys: string[]): Record<string, V> {
+        const result: Record<string, V> = {};
+        for (const [k, v] of Object.entries(this.params)) {
+            if (keys.includes(k)) {
+                result[k] = v;
+            }
+        }
+        return result;
+    }
+
+    getAllExcept(...keys: string[]): Record<string, V> {
+        const result: Record<string, V> = {};
+        for (const [k, v] of Object.entries(this.params)) {
+            if (!keys.includes(k)) {
+                result[k] = v;
+            }
+        }
+        return result;
+    }
+
+    with(params: Record<string, V>): this {
+        const clone = ObjectFactory.clone(this);
+        clone.params = params;
+        return clone;
+    }
+
+    withAdded(params: Record<string, V>): this {
+        const clone = ObjectFactory.clone(this);
+        clone.params = { ...this.params, ...params };
+        return clone;
+    }
+}

package/src/Valkyrja/Http/Message/Param/AttributeParamCollection.ts

@@ -0,0 +1,13 @@
+/*
+ * This file is part of the Valkyrja package.
+ *
+ * (c) Melech Mizrachi <melechmizrachi@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+import type { AttributeParamCollectionContract } from './Contract/AttributeParamCollectionContract.js';
+import { ParamCollection } from './Abstract/ParamCollection.js';
+
+export class AttributeParamCollection extends ParamCollection implements AttributeParamCollectionContract {}

package/src/Valkyrja/Http/Message/Param/Contract/AttributeParamCollectionContract.ts

@@ -0,0 +1,12 @@
+/*
+ * This file is part of the Valkyrja package.
+ *
+ * (c) Melech Mizrachi <melechmizrachi@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+import type { ParamCollectionContract } from './ParamCollectionContract.js';
+
+export type AttributeParamCollectionContract = ParamCollectionContract;

package/src/Valkyrja/Http/Message/Param/Contract/CookieParamCollectionContract.ts

@@ -0,0 +1,12 @@
+/*
+ * This file is part of the Valkyrja package.
+ *
+ * (c) Melech Mizrachi <melechmizrachi@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+import type { ParamCollectionContract } from './ParamCollectionContract.js';
+
+export type CookieParamCollectionContract = ParamCollectionContract<string>;

package/src/Valkyrja/Http/Message/Param/Contract/ParamCollectionContract.ts

@@ -0,0 +1,18 @@
+/*
+ * This file is part of the Valkyrja package.
+ *
+ * (c) Melech Mizrachi <melechmizrachi@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+export interface ParamCollectionContract<V = unknown> {
+    has(key: string): boolean;
+    get(key: string): V | undefined;
+    getAll(): Record<string, V>;
+    getOnly(...keys: string[]): Record<string, V>;
+    getAllExcept(...keys: string[]): Record<string, V>;
+    with(params: Record<string, V>): this;
+    withAdded(params: Record<string, V>): this;
+}

package/src/Valkyrja/Http/Message/Param/Contract/ParsedBodyParamCollectionContract.ts

@@ -0,0 +1,12 @@
+/*
+ * This file is part of the Valkyrja package.
+ *
+ * (c) Melech Mizrachi <melechmizrachi@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+import type { ParamCollectionContract } from './ParamCollectionContract.js';
+
+export type ParsedBodyParamCollectionContract = ParamCollectionContract<string | string[]>;

package/src/Valkyrja/Http/Message/Param/Contract/ParsedJsonParamCollectionContract.ts

@@ -0,0 +1,12 @@
+/*
+ * This file is part of the Valkyrja package.
+ *
+ * (c) Melech Mizrachi <melechmizrachi@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+import type { ParamCollectionContract } from './ParamCollectionContract.js';
+
+export type ParsedJsonParamCollectionContract = ParamCollectionContract;

package/src/Valkyrja/Http/Message/Param/Contract/QueryParamCollectionContract.ts

@@ -0,0 +1,12 @@
+/*
+ * This file is part of the Valkyrja package.
+ *
+ * (c) Melech Mizrachi <melechmizrachi@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+import type { ParamCollectionContract } from './ParamCollectionContract.js';
+
+export type QueryParamCollectionContract = ParamCollectionContract<string | string[]>;

package/src/Valkyrja/Http/Message/Param/Contract/ServerParamCollectionContract.ts

@@ -0,0 +1,12 @@
+/*
+ * This file is part of the Valkyrja package.
+ *
+ * (c) Melech Mizrachi <melechmizrachi@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+import type { ParamCollectionContract } from './ParamCollectionContract.js';
+
+export type ServerParamCollectionContract = ParamCollectionContract<string | string[]>;

package/src/Valkyrja/Http/Message/Param/CookieParamCollection.ts

@@ -0,0 +1,13 @@
+/*
+ * This file is part of the Valkyrja package.
+ *
+ * (c) Melech Mizrachi <melechmizrachi@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+import type { CookieParamCollectionContract } from './Contract/CookieParamCollectionContract.js';
+import { ParamCollection } from './Abstract/ParamCollection.js';
+
+export class CookieParamCollection extends ParamCollection<string> implements CookieParamCollectionContract {}

package/src/Valkyrja/Http/Message/Param/ParsedBodyParamCollection.ts

@@ -0,0 +1,15 @@
+/*
+ * This file is part of the Valkyrja package.
+ *
+ * (c) Melech Mizrachi <melechmizrachi@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+import type { ParsedBodyParamCollectionContract } from './Contract/ParsedBodyParamCollectionContract.js';
+import { ParamCollection } from './Abstract/ParamCollection.js';
+
+export class ParsedBodyParamCollection
+    extends ParamCollection<string | string[]>
+    implements ParsedBodyParamCollectionContract {}

package/src/Valkyrja/Http/Message/Param/ParsedJsonParamCollection.ts

@@ -0,0 +1,13 @@
+/*
+ * This file is part of the Valkyrja package.
+ *
+ * (c) Melech Mizrachi <melechmizrachi@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+import type { ParsedJsonParamCollectionContract } from './Contract/ParsedJsonParamCollectionContract.js';
+import { ParamCollection } from './Abstract/ParamCollection.js';
+
+export class ParsedJsonParamCollection extends ParamCollection implements ParsedJsonParamCollectionContract {}

package/src/Valkyrja/Http/Message/Param/QueryParamCollection.ts

@@ -0,0 +1,13 @@
+/*
+ * This file is part of the Valkyrja package.
+ *
+ * (c) Melech Mizrachi <melechmizrachi@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+import type { QueryParamCollectionContract } from './Contract/QueryParamCollectionContract.js';
+import { ParamCollection } from './Abstract/ParamCollection.js';
+
+export class QueryParamCollection extends ParamCollection<string | string[]> implements QueryParamCollectionContract {}

package/src/Valkyrja/Http/Message/Param/ServerParamCollection.ts

@@ -0,0 +1,15 @@
+/*
+ * This file is part of the Valkyrja package.
+ *
+ * (c) Melech Mizrachi <melechmizrachi@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+import type { ServerParamCollectionContract } from './Contract/ServerParamCollectionContract.js';
+import { ParamCollection } from './Abstract/ParamCollection.js';
+
+export class ServerParamCollection
+    extends ParamCollection<string | string[]>
+    implements ServerParamCollectionContract {}

package/src/Valkyrja/Http/Message/Provider/HttpMessageServiceProvider.ts

@@ -0,0 +1,30 @@
+/*
+ * This file is part of the Valkyrja package.
+ *
+ * (c) Melech Mizrachi <melechmizrachi@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+import { ResponseFactory } from '../Response/Factory/ResponseFactory.js';
+import { HttpMessageServiceId } from '../Constant/HttpMessageServiceId.js';
+
+import type { ContainerContract } from '../../../Container/Manager/Contract/ContainerContract.js';
+import type { ResponseFactoryContract } from '../Response/Factory/Contract/ResponseFactoryContract.js';
+import type { ServiceProviderContract } from '../../../Container/Provider/Contract/ServiceProviderContract.js';
+
+export class HttpMessageServiceProvider implements ServiceProviderContract {
+    publishers(): Record<string, (container: ContainerContract) => void> {
+        return {
+            [HttpMessageServiceId.ResponseFactoryContract]: HttpMessageServiceProvider.publishResponseFactory,
+        };
+    }
+
+    static publishResponseFactory(this: void, container: ContainerContract): void {
+        container.setSingleton<ResponseFactoryContract>(
+            HttpMessageServiceId.ResponseFactoryContract,
+            new ResponseFactory(),
+        );
+    }
+}

package/src/Valkyrja/Http/Message/Request/Contract/JsonServerRequestContract.ts

@@ -0,0 +1,16 @@
+/*
+ * This file is part of the Valkyrja package.
+ *
+ * (c) Melech Mizrachi <melechmizrachi@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+import type { ServerRequestContract } from './ServerRequestContract.js';
+import type { ParsedJsonParamCollectionContract } from '../../Param/Contract/ParsedJsonParamCollectionContract.js';
+
+export interface JsonServerRequestContract extends ServerRequestContract {
+    getParsedJson(): ParsedJsonParamCollectionContract;
+    withParsedJson(params: ParsedJsonParamCollectionContract): this;
+}

package/src/Valkyrja/Http/Message/Request/Contract/RequestContract.ts

@@ -0,0 +1,21 @@
+/*
+ * This file is part of the Valkyrja package.
+ *
+ * (c) Melech Mizrachi <melechmizrachi@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+import type { MessageContract } from '../../Contract/MessageContract.js';
+import type { UriContract } from '../../Uri/Contract/UriContract.js';
+import type { RequestMethod } from '../../Enum/RequestMethod.js';
+
+export interface RequestContract extends MessageContract {
+    getRequestTarget(): string;
+    withRequestTarget(requestTarget: string): this;
+    getMethod(): RequestMethod;
+    withMethod(method: RequestMethod): this;
+    getUri(): UriContract;
+    withUri(uri: UriContract, preserveHost?: boolean): this;
+}

package/src/Valkyrja/Http/Message/Request/Contract/ServerRequestContract.ts

@@ -0,0 +1,32 @@
+/*
+ * This file is part of the Valkyrja package.
+ *
+ * (c) Melech Mizrachi <melechmizrachi@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+import type { RequestContract } from './RequestContract.js';
+import type { UploadedFileCollectionContract } from '../../File/Collection/Contract/UploadedFileCollectionContract.js';
+import type { AttributeParamCollectionContract } from '../../Param/Contract/AttributeParamCollectionContract.js';
+import type { CookieParamCollectionContract } from '../../Param/Contract/CookieParamCollectionContract.js';
+import type { ParsedBodyParamCollectionContract } from '../../Param/Contract/ParsedBodyParamCollectionContract.js';
+import type { QueryParamCollectionContract } from '../../Param/Contract/QueryParamCollectionContract.js';
+import type { ServerParamCollectionContract } from '../../Param/Contract/ServerParamCollectionContract.js';
+
+export interface ServerRequestContract extends RequestContract {
+    getServerParams(): ServerParamCollectionContract;
+    withServerParams(server: ServerParamCollectionContract): this;
+    getCookieParams(): CookieParamCollectionContract;
+    withCookieParams(cookies: CookieParamCollectionContract): this;
+    getQueryParams(): QueryParamCollectionContract;
+    withQueryParams(query: QueryParamCollectionContract): this;
+    getUploadedFiles(): UploadedFileCollectionContract;
+    withUploadedFiles(uploadedFiles: UploadedFileCollectionContract): this;
+    getParsedBody(): ParsedBodyParamCollectionContract;
+    withParsedBody(params: ParsedBodyParamCollectionContract): this;
+    getAttributes(): AttributeParamCollectionContract;
+    withAttributes(attributes: AttributeParamCollectionContract): this;
+    isXmlHttpRequest(): boolean;
+}

package/src/Valkyrja/Http/Message/Request/Factory/RequestFactory.ts

@@ -0,0 +1,106 @@
+/*
+ * This file is part of the Valkyrja package.
+ *
+ * (c) Melech Mizrachi <melechmizrachi@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+import type { IncomingMessage } from 'node:http';
+import { ServerRequest } from '../ServerRequest.js';
+import { JsonServerRequest } from '../JsonServerRequest.js';
+import { HeaderCollection } from '../../Header/Collection/HeaderCollection.js';
+import { Header } from '../../Header/Header.js';
+import { CookieParamCollection } from '../../Param/CookieParamCollection.js';
+import { QueryParamCollection } from '../../Param/QueryParamCollection.js';
+import { ServerParamCollection } from '../../Param/ServerParamCollection.js';
+import { ParsedBodyParamCollection } from '../../Param/ParsedBodyParamCollection.js';
+import { UploadedFileCollection } from '../../File/Collection/UploadedFileCollection.js';
+import { CookieFactory } from '../../Header/Factory/CookieFactory.js';
+import { ProtocolVersion } from '../../Enum/ProtocolVersion.js';
+import { RequestMethod } from '../../Enum/RequestMethod.js';
+import { Stream } from '../../Stream/Stream.js';
+import { UriFactory } from '../../Uri/Factory/UriFactory.js';
+
+export abstract class RequestFactory {
+    static fromNodeRequest(req: IncomingMessage): ServerRequest {
+        return RequestFactory.buildFromNodeRequest(req, ServerRequest);
+    }
+
+    static jsonFromNodeRequest(req: IncomingMessage): JsonServerRequest {
+        return RequestFactory.buildFromNodeRequest(req, JsonServerRequest) as JsonServerRequest;
+    }
+
+    protected static buildFromNodeRequest(req: IncomingMessage, RequestClass: typeof ServerRequest): ServerRequest {
+        const rawHeaders = req.headers;
+        const headers: Header[] = [];
+
+        for (const [name, value] of Object.entries(rawHeaders)) {
+            if (value == null) {
+                continue;
+            }
+            const headerValue = Array.isArray(value) ? value.join(', ') : value;
+            headers.push(new Header(name, headerValue));
+        }
+
+        const headerCollection = new HeaderCollection(...headers);
+
+        const host = rawHeaders.host ?? 'localhost';
+        const scheme = (req.socket as { encrypted?: boolean }).encrypted ? 'https' : 'http';
+        const rawUrl = req.url ?? '/';
+        const uri = UriFactory.fromString(`${scheme}://${host}${rawUrl}`);
+
+        const cookieHeader = rawHeaders.cookie ?? '';
+        const cookies = cookieHeader ? CookieFactory.parseCookieHeader(cookieHeader) : {};
+        const searchParams = new URL(`${scheme}://${host}${rawUrl}`).searchParams;
+        const query: Record<string, string | string[]> = {};
+
+        for (const [key, value] of searchParams.entries()) {
+            const existing = query[key];
+            if (existing === undefined) {
+                query[key] = value;
+            } else if (Array.isArray(existing)) {
+                existing.push(value);
+            } else {
+                query[key] = [existing, value];
+            }
+        }
+
+        const serverParams: Record<string, string | string[]> = {
+            method: req.method ?? 'GET',
+            httpVersion: req.httpVersion,
+        };
+
+        const protocol = RequestFactory.getProtocolVersion(req.httpVersion);
+        const method = RequestMethod[(req.method ?? 'GET').toUpperCase() as keyof typeof RequestMethod];
+
+        return new RequestClass(
+            uri,
+            method,
+            new Stream(),
+            headerCollection,
+            protocol,
+            new ServerParamCollection(serverParams),
+            new CookieParamCollection(cookies),
+            new QueryParamCollection(query),
+            new ParsedBodyParamCollection(),
+            new UploadedFileCollection(),
+        );
+    }
+
+    protected static getProtocolVersion(httpVersion: string): ProtocolVersion {
+        switch (httpVersion) {
+            case '1.0':
+                return ProtocolVersion.V1;
+            case '2':
+            case '2.0':
+                return ProtocolVersion.V2;
+            case '3':
+            case '3.0':
+                return ProtocolVersion.V3;
+            default:
+                return ProtocolVersion.V1_1;
+        }
+    }
+}

package/src/Valkyrja/Http/Message/Request/JsonServerRequest.ts

@@ -0,0 +1,76 @@
+/*
+ * This file is part of the Valkyrja package.
+ *
+ * (c) Melech Mizrachi <melechmizrachi@gmail.com>
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+import type { JsonServerRequestContract } from './Contract/JsonServerRequestContract.js';
+import type { UriContract } from '../Uri/Contract/UriContract.js';
+import type { HeaderCollectionContract } from '../Header/Collection/Contract/HeaderCollectionContract.js';
+import type { StreamContract } from '../Stream/Contract/StreamContract.js';
+import type { UploadedFileCollectionContract } from '../File/Collection/Contract/UploadedFileCollectionContract.js';
+import type { CookieParamCollectionContract } from '../Param/Contract/CookieParamCollectionContract.js';
+import type { ParsedBodyParamCollectionContract } from '../Param/Contract/ParsedBodyParamCollectionContract.js';
+import type { ParsedJsonParamCollectionContract } from '../Param/Contract/ParsedJsonParamCollectionContract.js';
+import type { QueryParamCollectionContract } from '../Param/Contract/QueryParamCollectionContract.js';
+import type { ServerParamCollectionContract } from '../Param/Contract/ServerParamCollectionContract.js';
+import { ServerRequest } from './ServerRequest.js';
+import { HeaderCollection } from '../Header/Collection/HeaderCollection.js';
+import { CookieParamCollection } from '../Param/CookieParamCollection.js';
+import { ParsedBodyParamCollection } from '../Param/ParsedBodyParamCollection.js';
+import { ParsedJsonParamCollection } from '../Param/ParsedJsonParamCollection.js';
+import { QueryParamCollection } from '../Param/QueryParamCollection.js';
+import { ServerParamCollection } from '../Param/ServerParamCollection.js';
+import { UploadedFileCollection } from '../File/Collection/UploadedFileCollection.js';
+import { ContentTypeValue } from '../Constant/ContentTypeValue.js';
+import { HeaderName } from '../Constant/HeaderName.js';
+import { ProtocolVersion } from '../Enum/ProtocolVersion.js';
+import { RequestMethod } from '../Enum/RequestMethod.js';
+import { Stream } from '../Stream/Stream.js';
+import { Uri } from '../Uri/Uri.js';
+import { ObjectFactory } from '../../../Type/Object/Factory/ObjectFactory.js';
+
+export class JsonServerRequest extends ServerRequest implements JsonServerRequestContract {
+    protected parsedJson: ParsedJsonParamCollectionContract;
+
+    constructor(
+        uri: UriContract = new Uri(),
+        method: RequestMethod = RequestMethod.GET,
+        body: StreamContract = new Stream(),
+        headers: HeaderCollectionContract = new HeaderCollection(),
+        protocol: ProtocolVersion = ProtocolVersion.V1_1,
+        server: ServerParamCollectionContract = new ServerParamCollection(),
+        cookies: CookieParamCollectionContract = new CookieParamCollection(),
+        query: QueryParamCollectionContract = new QueryParamCollection(),
+        parsedBody: ParsedBodyParamCollectionContract = new ParsedBodyParamCollection(),
+        parsedJson: ParsedJsonParamCollectionContract = new ParsedJsonParamCollection(),
+        files: UploadedFileCollectionContract = new UploadedFileCollection(),
+    ) {
+        super(uri, method, body, headers, protocol, server, cookies, query, parsedBody, files);
+        this.parsedJson = parsedJson;
+
+        const contentType = headers.getHeaderLine(HeaderName.CONTENT_TYPE);
+
+        if (contentType.includes(ContentTypeValue.APPLICATION_JSON)) {
+            const bodyContents = body.toString();
+
+            if (bodyContents !== '') {
+                const parsed = JSON.parse(bodyContents) as Record<string, unknown>;
+                this.parsedJson = new ParsedJsonParamCollection(parsed);
+            }
+        }
+    }
+
+    getParsedJson(): ParsedJsonParamCollectionContract {
+        return this.parsedJson;
+    }
+
+    withParsedJson(params: ParsedJsonParamCollectionContract): this {
+        const clone = ObjectFactory.clone(this);
+        clone.parsedJson = params;
+        return clone;
+    }
+}