cspell-lib 9.6.1 → 9.6.3

package/dist/rpc/client.js

@@ -1,364 +0,0 @@
-import { AbortRPCRequestError, CanceledRPCRequestError, TimeoutRPCRequestError } from './errors.js';
-import { Future } from './Future.js';
-import { MessagePortNotifyEvents } from './MessagePortEvents.js';
-import { createRPCCancelRequest, createRPCMethodRequest, createRPCOkRequest, createRPCReadyRequest, isBaseResponse, isRPCCanceledResponse, isRPCErrorResponse, isRPCReadyResponse, isRPCResponse, } from './modelsHelpers.js';
-const DefaultOkOptions = {
-    timeoutMs: 200,
-};
-/**
- * The RPC Client.
- */
-class RPCClientImpl {
-    #port;
-    #count = 0;
-    #options;
-    #pendingRequests = new Map();
-    #pendingRequestsByPromise = new WeakMap();
-    #defaultTimeoutMs;
-    #isReady;
-    #ready;
-    /**
-     * Create an RPC Client.
-     * @param config - The client configuration.
-     */
-    constructor(config) {
-        this.#port = new MessagePortNotifyEvents(config.port);
-        this.#options = config;
-        this.#defaultTimeoutMs = config.timeoutMs;
-        this.#isReady = false;
-        this.#ready = new Future();
-        this.#port.onMessage((msg) => this.#processMessageFromServer(msg));
-        this.#port.start();
-    }
-    /**
-     * Make a request to the RPC server.
-     *
-     * It is unlikely you need to use this method directly. Consider using `call` or `getApi` instead.
-     *
-     * @param method - The method name.
-     * @param params - The method parameters.
-     * @param options - Request options including abort signal and timeout.
-     * @returns The pending client request.
-     */
-    request(method, params, options) {
-        // Register the request.
-        const id = this.#calcId(method);
-        const request = createRPCMethodRequest(id, method, params);
-        const pendingRequest = this.#sendRequest(request, options);
-        const response = pendingRequest.response.then(handleResponse);
-        // Record the promise to request ID mapping.
-        this.#pendingRequestsByPromise.set(response, id);
-        const clientRequest = {
-            id,
-            method,
-            response,
-            abort: pendingRequest.abort,
-            cancel: pendingRequest.cancel,
-            get isResolved() {
-                return pendingRequest.isResolved;
-            },
-            get isCanceled() {
-                return pendingRequest.isCanceled;
-            },
-        };
-        return clientRequest;
-        function handleResponse(res) {
-            if (isRPCErrorResponse(res)) {
-                throw res.error;
-            }
-            if (isRPCCanceledResponse(res)) {
-                throw new CanceledRPCRequestError(`Request ${id} was canceled`);
-            }
-            if (isRPCResponse(res)) {
-                return res.result;
-            }
-            throw new Error(`Malformed response for request ${id}`); // Should not happen.
-        }
-    }
-    #sendRequest(request, options = {}) {
-        // Register the request.
-        const id = request.id;
-        const requestType = request.type;
-        let isResolved = false;
-        let isCanceled = false;
-        const timeoutMs = options.timeoutMs ?? this.#defaultTimeoutMs;
-        const timeoutSignal = timeoutMs ? AbortSignal.timeout(timeoutMs) : undefined;
-        const future = new Future();
-        options.signal?.addEventListener('abort', abort);
-        timeoutSignal?.addEventListener('abort', timeoutHandler);
-        const response = future.promise;
-        const cancelRequest = () => this.#port.postMessage(createRPCCancelRequest(id));
-        const cancel = async () => {
-            if (isResolved || isCanceled)
-                return isCanceled;
-            cancelRequest();
-            await response.catch(() => { });
-            return isCanceled;
-        };
-        const pendingRequest = {
-            id,
-            request,
-            response,
-            handleResponse,
-            abort,
-            cancel,
-            get isResolved() {
-                return isResolved;
-            },
-            get isCanceled() {
-                return isCanceled;
-            },
-        };
-        this.#pendingRequests.set(id, pendingRequest);
-        this.#pendingRequestsByPromise.set(response, id);
-        const cleanup = () => {
-            options.signal?.removeEventListener('abort', abort);
-            timeoutSignal?.removeEventListener('abort', timeoutHandler);
-            this.#cleanupPendingRequest(pendingRequest);
-        };
-        this.#port.postMessage(request);
-        return pendingRequest;
-        function timeoutHandler() {
-            abort(new TimeoutRPCRequestError(`Request ${requestType} ${id} timed out after ${timeoutMs} ms`));
-        }
-        function abort(reason) {
-            if (isResolved || isCanceled)
-                return;
-            isCanceled = true;
-            cancelRequest();
-            reason = reason instanceof Event ? undefined : reason;
-            reason ??= `Request ${id} aborted`;
-            reason = typeof reason === 'string' ? new AbortRPCRequestError(reason) : reason;
-            cleanup();
-            future.reject(reason);
-        }
-        function handleResponse(res) {
-            // Do not process anything if already resolved or canceled.
-            if (isResolved || isCanceled)
-                return;
-            isResolved = true;
-            if (isRPCCanceledResponse(res)) {
-                isCanceled = true;
-            }
-            cleanup();
-            future.resolve(res);
-        }
-    }
-    /**
-     * Check the health of the RPC server.
-     * @param options - used to set timeout and abort signal.
-     * @returns resolves to true if the server is OK, false on timeout.
-     */
-    async isOK(options = DefaultOkOptions) {
-        try {
-            const req = this.#sendRequest(createRPCOkRequest(this.#calcId('isOK')), options);
-            const res = await req.response;
-            return isBaseResponse(res) && res.type === 'ok' && res.code === 200;
-        }
-        catch {
-            return false;
-        }
-    }
-    /**
-     * The current known ready state of the RPC server.
-     * - `true` - The server is ready.
-     * - `false` - The server is not ready.
-     */
-    get isReady() {
-        return this.#isReady;
-    }
-    /**
-     * Check if the RPC server is ready. If already ready, returns true immediately.
-     * If not ready, sends a 'ready' request to the server.
-     * @param options - used to set timeout and abort signal.
-     * @returns resolves to true when the server is ready, rejects if the request times out or fails.
-     */
-    async ready(options) {
-        if (this.#isReady)
-            return true;
-        // We send the request, but we do not care about the result other than it succeeded.
-        await this.#sendRequest(createRPCReadyRequest(this.#calcId('ready')), options).response;
-        return this.#isReady; // We are returning the current state.
-    }
-    /**
-     * Call a method on the RPC server.
-     * @param method - The method name.
-     * @param params - The method parameters.
-     * @param options - Call options including abort signal.
-     * @returns A Promise with the method result.
-     */
-    call(method, params, options) {
-        const req = this.request(method, params, options);
-        return req.response;
-    }
-    /**
-     * Get the API for the given method names.
-     *
-     * This is useful passing the API to other parts of the code that do not need to know about the RPCClient.
-     *
-     * @param methods - The method names to include in the API.
-     * @returns A partial API with the requested methods.
-     */
-    getApi(methods) {
-        const apiEntries = methods.map((method) => [method, ((...params) => this.call(method, params))]);
-        return Object.fromEntries(apiEntries);
-    }
-    /**
-     * Get info about a pending request by its RequestID.
-     * @param id - The RequestID of the pending request.
-     * @returns The found pending request or undefined if not found.
-     */
-    getPendingRequestById(id) {
-        return this.#pendingRequests.get(id);
-    }
-    /**
-     * Get info about a pending request by the promise returned using `call` or an api method.
-     * @param id - The RequestID of the pending request.
-     * @returns The found pending request or undefined if not found.
-     */
-    getPendingRequestByPromise(promise) {
-        const requestId = this.#pendingRequestsByPromise.get(promise);
-        if (!requestId)
-            return undefined;
-        return this.getPendingRequestById(requestId);
-    }
-    /**
-     * Get the number of pending requests.
-     */
-    get length() {
-        return this.#pendingRequests.size;
-    }
-    #calcId(method) {
-        const suffix = this.#options.randomUUID ? this.#options.randomUUID() : `${performance.now()}`;
-        return `${method}-${++this.#count}-${suffix}`;
-    }
-    #cleanupPendingRequest(request) {
-        this.#pendingRequests.delete(request.id);
-        this.#pendingRequestsByPromise.delete(request.response);
-    }
-    #processMessageFromServer(msg) {
-        // Ignore messages that are not RPC messages
-        if (!isBaseResponse(msg))
-            return;
-        this.#handleReadyResponse(msg);
-        const pendingRequest = this.#pendingRequests.get(msg.id);
-        if (!pendingRequest)
-            return;
-        pendingRequest.handleResponse(msg);
-    }
-    /**
-     * Handle possible ready response messages.
-     * @param msg - The message to handle.
-     */
-    #handleReadyResponse(msg) {
-        if (!isRPCReadyResponse(msg))
-            return;
-        if (this.#ready.isResolved)
-            return;
-        this.#isReady = msg.code === 200;
-        this.#ready.resolve(this.#isReady);
-    }
-    /**
-     * Abort a pending request by its promise.
-     *
-     * Note: the request promise will be rejected with an AbortRequestError.
-     * @param promise - The promise returned by the request.
-     * @param reason - The reason for aborting the request.
-     * @returns True if the request was found and aborted, false otherwise.
-     */
-    abortPromise(promise, reason) {
-        const pendingRequest = this.getPendingRequestByPromise(promise);
-        if (!pendingRequest)
-            return false;
-        return this.abortRequest(pendingRequest.id, reason);
-    }
-    /**
-     * Abort a pending request by its RequestId.
-     *
-     * Note: the request promise will be rejected with an AbortRequestError.
-     * @param requestId - The RequestID of the request to abort.
-     * @param reason - The reason for aborting the request.
-     * @returns True if the request was found and aborted, false otherwise.
-     */
-    abortRequest(requestId, reason) {
-        const pendingRequest = this.getPendingRequestById(requestId);
-        if (!pendingRequest)
-            return false;
-        pendingRequest.abort(reason);
-        return true;
-    }
-    /**
-     * Abort all pending requests.
-     *
-     * Note: each request promise will be rejected with an AbortRequestError.
-     *
-     * @param reason - The reason for aborting the request.
-     */
-    abortAllRequests(reason) {
-        for (const pendingRequest of this.#pendingRequests.values()) {
-            try {
-                pendingRequest.abort(reason);
-            }
-            catch {
-                // ignore
-            }
-        }
-    }
-    /**
-     * Cancel a pending request by its RequestID.
-     *
-     * Tries to cancel the request by sending a cancel request to the server and waiting for the response.
-     * @param id - The RequestID of the request to cancel.
-     * @returns resolves to true if the request was found and canceled, false otherwise.
-     */
-    async cancelRequest(id) {
-        const pendingRequest = this.getPendingRequestById(id);
-        if (!pendingRequest)
-            return false;
-        return await pendingRequest.cancel();
-    }
-    /**
-     * Cancel a pending request by its Promise.
-     *
-     * Tries to cancel the request by sending a cancel request to the server and waiting for the response.
-     * @param id - The RequestID of the request to cancel.
-     * @returns resolves to true if the request was found and canceled, false otherwise.
-     */
-    async cancelPromise(promise) {
-        const request = this.getPendingRequestByPromise(promise);
-        if (!request)
-            return false;
-        return this.cancelRequest(request.id);
-    }
-    /**
-     * Set the default timeout for requests. Requests can override this value.
-     * @param timeoutMs - the timeout in milliseconds
-     */
-    setTimeout(timeoutMs) {
-        this.#defaultTimeoutMs = timeoutMs;
-    }
-    /**
-     * Dispose of the RPC client, aborting all pending requests and closing the port if specified in options.
-     */
-    [Symbol.dispose]() {
-        this.abortAllRequests(new Error('RPC Client disposed'));
-        this.#pendingRequests.clear();
-        if (this.#options.closePortOnDispose) {
-            this.#port.close();
-        }
-        this.#port[Symbol.dispose]();
-    }
-}
-/**
- * The RPC Client.
- */
-export class RPCClient extends RPCClientImpl {
-    /**
-     * Create an RPC Client.
-     * @param config - The client configuration.
-     */
-    constructor(config) {
-        super(config);
-    }
-}
-//# sourceMappingURL=client.js.map

package/dist/rpc/errors.d.ts

@@ -1,24 +0,0 @@
-export declare class RPCRequestError extends Error {
-    constructor(message: string);
-}
-export declare class AbortRPCRequestError extends RPCRequestError {
-    constructor(message: string);
-}
-export declare class TimeoutRPCRequestError extends RPCRequestError {
-    constructor(message: string);
-}
-export declare class UnknownMethodRPCRequestError extends RPCRequestError {
-    method: string;
-    constructor(method: string, message?: string);
-}
-export declare class MalformedRPCRequestError extends RPCRequestError {
-    request?: unknown;
-    constructor(message: string, request?: unknown);
-}
-export declare class CanceledRPCRequestError extends RPCRequestError {
-    constructor(message?: string);
-}
-export declare class AlreadyDisposedError extends Error {
-    constructor();
-}
-//# sourceMappingURL=errors.d.ts.map

package/dist/rpc/errors.js

@@ -1,47 +0,0 @@
-export class RPCRequestError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = 'RPCRequestError';
-    }
-}
-export class AbortRPCRequestError extends RPCRequestError {
-    constructor(message) {
-        super(message);
-        this.name = 'AbortRPCRequestError';
-    }
-}
-export class TimeoutRPCRequestError extends RPCRequestError {
-    constructor(message) {
-        super(message);
-        this.name = 'TimeoutRPCRequestError';
-    }
-}
-export class UnknownMethodRPCRequestError extends RPCRequestError {
-    method;
-    constructor(method, message) {
-        super(message || `Unknown method: ${method}`);
-        this.name = 'UnknownMethodRPCRequestError';
-        this.method = method;
-    }
-}
-export class MalformedRPCRequestError extends RPCRequestError {
-    request;
-    constructor(message, request) {
-        super(message);
-        this.name = 'MalformedRPCRequestError';
-        this.request = request;
-    }
-}
-export class CanceledRPCRequestError extends RPCRequestError {
-    constructor(message) {
-        super(message ?? 'The RPC request was canceled');
-        this.name = 'CanceledRPCRequestError';
-    }
-}
-export class AlreadyDisposedError extends Error {
-    constructor() {
-        super('NotifyEmitter has been disposed.');
-        this.name = 'AlreadyDisposedError';
-    }
-}
-//# sourceMappingURL=errors.js.map

package/dist/rpc/index.d.ts

@@ -1,11 +0,0 @@
-export type { RPCClientConfiguration, RPCClientOptions } from './client.js';
-export { RPCClient } from './client.js';
-export { AbortRPCRequestError, CanceledRPCRequestError, RPCRequestError, TimeoutRPCRequestError, UnknownMethodRPCRequestError, } from './errors.js';
-export type { MessagePortLike } from './messagePort.js';
-export type { NotifyEvent, NotifyHandler, NotifyOnceEvent } from './notify.js';
-export { NotifyEmitter, notifyEventOnce, notifyEventToPromise } from './notify.js';
-export type { RPCProtocol, RPCProtocolMethods } from './protocol.js';
-export { protocolDefinition, protocolMethods } from './protocol.js';
-export type { RPCServerConfiguration, RPCServerOptions } from './server.js';
-export { RPCServer } from './server.js';
-//# sourceMappingURL=index.d.ts.map

package/dist/rpc/index.js

@@ -1,6 +0,0 @@
-export { RPCClient } from './client.js';
-export { AbortRPCRequestError, CanceledRPCRequestError, RPCRequestError, TimeoutRPCRequestError, UnknownMethodRPCRequestError, } from './errors.js';
-export { NotifyEmitter, notifyEventOnce, notifyEventToPromise } from './notify.js';
-export { protocolDefinition, protocolMethods } from './protocol.js';
-export { RPCServer } from './server.js';
-//# sourceMappingURL=index.js.map

package/dist/rpc/messagePort.d.ts

@@ -1,34 +0,0 @@
-export interface MessagePortLike {
-    /**
-     * Sends a message to the port.
-     * @param message - anything supported by postMessage
-     */
-    postMessage(message: unknown): void;
-    /**
-     * Sets a function to handle the 'close' event.
-     */
-    addListener(event: 'close', listener: (ev: Event) => void): this;
-    /**
-     * Sets a function to handle messages received on the port.
-     * Set to undefined to remove the handler.
-     */
-    addListener(event: 'message', listener: (value: unknown) => void): this;
-    /**
-     * Sets a function to handle message errors received on the port.
-     * Set to undefined to remove the handler.
-     */
-    addListener(event: 'messageerror', listener: (error: Error) => void): this;
-    removeListener(event: 'close', listener: (ev: Event) => void, options?: EventListenerOptions): this;
-    removeListener(event: 'message', listener: (value: unknown) => void, options?: EventListenerOptions): this;
-    removeListener(event: 'messageerror', listener: (error: Error) => void, options?: EventListenerOptions): this;
-    /**
-     * Closes the port and stops it from receiving messages.
-     */
-    close?: () => void;
-    /**
-     * Start receiving messages on the port.
-     * Note: Some MessagePort implementations may start automatically.
-     */
-    start?: () => void;
-}
-//# sourceMappingURL=messagePort.d.ts.map

package/dist/rpc/messagePort.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=messagePort.js.map

package/dist/rpc/models.d.ts

@@ -1,134 +0,0 @@
-/**
- * A Unique identifier for the request/response.
- */
-export type RequestID = number | string;
-export type ResponseCode = 0 | 200 | 400 | 408 | 500 | 503;
-/**
- * A base RPC Message.
- */
-export interface RPCMessage {
-    /**
-     * A signature to identify the message as an RPC message.
-     */
-    sig: 'RPC0';
-    /**
-     * The server Identifier used to identify the server instance.
-     * This allows multiple servers with different protocols to share the same communication channel.
-     */
-    sid?: string;
-    /**
-     * A Unique identifier for the request/response.
-     */
-    id: RequestID;
-    /**
-     * The type of message being sent.
-     */
-    type: 'request' | 'response' | 'cancel' | 'canceled' | 'ok' | 'ready';
-}
-export interface RCPBaseRequest extends RPCMessage {
-    /**
-     * The type of message being sent.
-     */
-    type: 'request' | 'cancel' | 'ok' | 'ready';
-}
-export interface RPCResponse extends RPCMessage {
-    /**
-     * The type of message being sent.
-     */
-    type: 'response' | 'canceled' | 'ok' | 'ready';
-    code: ResponseCode;
-    result?: unknown;
-    error?: RPCError | undefined;
-}
-/**
- * A message to check if the server is running.
- */
-export interface RPCOkRequestMessage extends RCPBaseRequest {
-    /**
-     * The type of message being sent.
-     */
-    type: 'ok';
-}
-/**
- * A message to check if the server is running.
- */
-export interface RPCOkResponseMessage extends RPCResponse {
-    type: 'ok';
-}
-/**
- * A message send from a client to request if the server is ready.
- * This can be sent once or multiple times. It allows for multiple clients
- * to wait for the server to be ready. When the server is ready it will respond
- * with a `RPCReadyResponseMessage`.
- *
- * This is useful when the server takes some time to initialize and clients
- * need to wait for it to be ready before sending other requests.
- *
- */
-export interface RPCReadyRequestMessage extends RCPBaseRequest {
-    /**
-     * The type of message being sent.
-     */
-    type: 'ready';
-}
-/**
- * A response message send to the client when the server is ready.
- * This is sent once when the server is initialized or upon request.
- *
- * This allows clients to know when the server is ready to accept requests.
- */
-export interface RPCReadyResponseMessage extends RPCResponse {
-    type: 'ready';
-}
-/**
- * A message to request a method call.
- */
-export interface RPCRequestMessage<TParams = unknown> extends RCPBaseRequest {
-    type: 'request';
-    method: string;
-    params: TParams;
-}
-/**
- * A message to cancel a request.
- */
-export interface RPCCancelRequestMessage extends RCPBaseRequest {
-    type: 'cancel';
-}
-/**
- * The response to a cancel request.
- */
-export interface RPCCanceledResponseMessage extends RPCResponse {
-    type: 'canceled';
-}
-/**
- * The response message for a request from the server.
- */
-export interface RPCResponseMessage<TResult = unknown> extends RPCResponse {
-    type: 'response';
-    result: TResult;
-    error?: undefined;
-}
-/**
- * The error information for a failed request.
- */
-export interface RequestError {
-    message: string;
-    cause?: unknown;
-}
-export type RPCError = RequestError | Error;
-export interface RPCErrorResponseMessage extends RPCResponse {
-    id: RequestID;
-    type: 'response';
-    error: RPCError;
-}
-export interface RPCPendingClientRequest<Method extends string, TResult extends Promise<unknown>> {
-    readonly id: RequestID;
-    readonly response: TResult;
-    readonly isResolved: boolean;
-    readonly isCanceled: boolean;
-    /** calling abort will cancel the request if it has not already been resolved. */
-    abort: AbortController['abort'];
-    cancel: () => Promise<boolean>;
-    readonly method: Method;
-}
-//# sourceMappingURL=models.d.ts.map

package/dist/rpc/models.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=models.js.map

package/dist/rpc/modelsHelpers.d.ts

@@ -1,56 +0,0 @@
-import type { RCPBaseRequest, RequestID, ResponseCode, RPCCanceledResponseMessage, RPCCancelRequestMessage, RPCError, RPCErrorResponseMessage, RPCMessage, RPCOkRequestMessage, RPCOkResponseMessage, RPCReadyRequestMessage, RPCReadyResponseMessage, RPCRequestMessage, RPCResponse, RPCResponseMessage } from './models.js';
-export declare function isRPCBaseMessage(message: unknown): message is RPCMessage;
-export declare function isBaseRequest(message: RPCMessage): message is RCPBaseRequest;
-export declare function isBaseResponse(message: unknown): message is RPCResponse;
-export declare function isRPCErrorResponse(response: unknown): response is RPCErrorResponseMessage;
-export declare function isRPCCancelRequest(request: RPCMessage): request is RPCCancelRequestMessage;
-export declare function isRPCCanceledResponse(response: RPCResponse): response is RPCCanceledResponseMessage;
-export declare function isRPCOkRequest(request: RPCMessage): request is RPCOkRequestMessage;
-export declare function isRPCOkResponse(response: RPCMessage): response is RPCOkResponseMessage;
-export declare function isRPCReadyRequest(request: RPCMessage): request is RPCReadyRequestMessage;
-export declare function isRPCReadyResponse(response: RPCMessage): response is RPCReadyResponseMessage;
-export declare function isRPCResponse<TResult>(response: RPCMessage): response is RPCResponseMessage<TResult>;
-export declare function isRPCRequest<P>(message: RPCMessage): message is RPCRequestMessage<P>;
-/**
- * Creates a RPC Request Message.
- * @param id - The unique request identifier.
- * @param method - The method name.
- * @param params - The parameters for the request.
- * @returns A RPC Request Message.
- */
-export declare function createRPCMethodRequest<P>(id: RequestID, method: string, params: P): RPCRequestMessage<P>;
-/**
- * Creates a cancel request message.
- * @param id - The request ID to be canceled.
- * @returns A cancel request message.
- */
-export declare function createRPCCancelRequest(id: RequestID): RPCCancelRequestMessage;
-/**
- * Creates a cancel request message.
- * @param id - The request ID to be canceled.
- * @param code - The response code
- *   - 200 (ok) - if canceled successfully upon request.
- *   - 408 (timeout) - if the cancellation was initiated by the server.
- *   - 503 (unavailable) - if the server is shutting down.
- * @returns A cancel request message.
- */
-export declare function createRPCCanceledResponse(id: RequestID, code: ResponseCode): RPCCanceledResponseMessage;
-/**
- * Creates a RPC Response Message.
- * @param id - The matching request ID.
- * @param result - the result of the request.
- * @returns A RPC Response Message.
- */
-export declare function createRPCResponse<TResult>(id: RequestID, result: TResult, code: ResponseCode): RPCResponseMessage<TResult>;
-/**
- * Creates a RPC Error Message.
- * @param id - The matching request ID for which the error occurred.
- * @param error - The error information.
- * @returns A RPC Error Message.
- */
-export declare function createRPCError(id: RequestID, error: RPCError, code: ResponseCode): RPCErrorResponseMessage;
-export declare function createRPCOkRequest(id: RequestID): RPCOkRequestMessage;
-export declare function createRPCOkResponse(id: RequestID, code: ResponseCode): RPCOkResponseMessage;
-export declare function createRPCReadyRequest(id: RequestID): RPCReadyRequestMessage;
-export declare function createRPCReadyResponse(id: RequestID, code: ResponseCode): RPCReadyResponseMessage;
-//# sourceMappingURL=modelsHelpers.d.ts.map