@rest-vir/define-service 0.0.2

package/dist/service/service-definition.d.ts

@@ -0,0 +1,80 @@
+import type { Overwrite } from '@augment-vir/common';
+import { IsEqual, SetRequired } from 'type-fest';
+import { EndpointPathBase } from '../endpoint/endpoint-path.js';
+import { EndpointDefinition, EndpointInit, WithFinalEndpointProps } from '../endpoint/endpoint.js';
+import { NoParam } from '../util/no-param.js';
+import { OriginRequirement } from '../util/origin.js';
+import { WebSocketDefinition, WebSocketInit, WithFinalWebSocketProps } from '../web-socket/web-socket-definition.js';
+import { MinimalService } from './minimal-service.js';
+/**
+ * A string used for type errors triggered when an endpoint path is defined without a leading slash.
+ *
+ * @category Internal
+ * @category Package : @rest-vir/define-service
+ * @package [`@rest-vir/define-service`](https://www.npmjs.com/package/@rest-vir/define-service)
+ */
+export type EndpointMustStartWithSlashTypeError = 'ERROR: endpoint must start with a slash';
+/**
+ * Base type used for the right side of "extends" in type parameters for generic endpoint
+ * definitions.
+ *
+ * @category Internal
+ * @category Package : @rest-vir/define-service
+ * @package [`@rest-vir/define-service`](https://www.npmjs.com/package/@rest-vir/define-service)
+ */
+export type BaseServiceEndpointsInit = Record<EndpointPathBase, EndpointInit>;
+/**
+ * Base type used for the right side of "extends" in type parameters for generic endpoint
+ * definitions.
+ *
+ * @category Internal
+ * @category Package : @rest-vir/define-service
+ * @package [`@rest-vir/define-service`](https://www.npmjs.com/package/@rest-vir/define-service)
+ */
+export type BaseServiceWebSocketsInit = Record<EndpointPathBase, WebSocketInit>;
+/**
+ * Init for a service. This is used as an input to `defineService`.
+ *
+ * @category Internal
+ * @category Package : @rest-vir/define-service
+ * @package [`@rest-vir/define-service`](https://www.npmjs.com/package/@rest-vir/define-service)
+ */
+export type ServiceInit<ServiceName extends string, EndpointsInit extends BaseServiceEndpointsInit | NoParam, WebSocketsInit extends BaseServiceWebSocketsInit | NoParam> = MinimalService<ServiceName> & {
+    requiredClientOrigin: NonNullable<OriginRequirement>;
+    webSockets?: IsEqual<WebSocketsInit, NoParam> extends true ? Record<EndpointPathBase, WebSocketInit> : {
+        [WebSocketPath in keyof WebSocketsInit]: WebSocketPath extends EndpointPathBase ? WebSocketsInit[WebSocketPath] : WebSocketPath extends EndpointMustStartWithSlashTypeError ? never : EndpointMustStartWithSlashTypeError;
+    };
+    endpoints?: IsEqual<EndpointsInit, NoParam> extends true ? Record<EndpointPathBase, EndpointInit> : {
+        [EndpointPath in keyof EndpointsInit]: EndpointPath extends EndpointPathBase ? EndpointsInit[EndpointPath] : EndpointPath extends EndpointMustStartWithSlashTypeError ? never : EndpointMustStartWithSlashTypeError;
+    };
+};
+/**
+ * A fully defined service (without executable endpoint implementations).
+ *
+ * @category Internal
+ * @category Package : @rest-vir/define-service
+ * @package [`@rest-vir/define-service`](https://www.npmjs.com/package/@rest-vir/define-service)
+ */
+export type ServiceDefinition<ServiceName extends string = any, EndpointsInit extends BaseServiceEndpointsInit | NoParam = NoParam, WebSocketsInit extends BaseServiceWebSocketsInit | NoParam = NoParam> = MinimalService<ServiceName> & {
+    requiredClientOrigin: NonNullable<OriginRequirement>;
+    /** Include the initial init object so a service can be composed. */
+    init: SetRequired<ServiceInit<ServiceName, EndpointsInit, WebSocketsInit>, 'endpoints' | 'webSockets'>;
+    webSockets: WebSocketsInit extends NoParam ? {
+        [WebSocketPath in EndpointPathBase]: Overwrite<WebSocketDefinition, {
+            searchParamsShape: any;
+            SearchParamsType: any;
+            protocolsShape: any;
+            ProtocolsType: any;
+        }>;
+    } : {
+        [WebSocketPath in keyof WebSocketsInit]: WebSocketPath extends EndpointPathBase ? WithFinalWebSocketProps<WebSocketsInit[WebSocketPath], WebSocketPath> : EndpointMustStartWithSlashTypeError;
+    };
+    endpoints: EndpointsInit extends NoParam ? {
+        [EndpointPath in EndpointPathBase]: Overwrite<EndpointDefinition, {
+            searchParamsShape: any;
+            SearchParamsType: any;
+        }>;
+    } : {
+        [EndpointPath in keyof EndpointsInit]: EndpointPath extends EndpointPathBase ? WithFinalEndpointProps<EndpointsInit[EndpointPath], EndpointPath> : EndpointMustStartWithSlashTypeError;
+    };
+};

package/dist/service/service-definition.error.d.ts

@@ -0,0 +1,35 @@
+import { type NoParam } from '../util/no-param.js';
+/**
+ * Parameters for {@link ServiceDefinitionError}
+ *
+ * @category Internal
+ * @category Package : @rest-vir/define-service
+ * @package [`@rest-vir/define-service`](https://www.npmjs.com/package/@rest-vir/define-service)
+ */
+export type ServiceDefinitionErrorParams = {
+    serviceName: string | NoParam;
+    errorMessage: string;
+    path: string | undefined;
+    isWebSocket: boolean | undefined;
+    isEndpoint: boolean | undefined;
+};
+/**
+ * An error thrown by endpoint and service validation assertions.
+ *
+ * @category Internal
+ * @category Package : @rest-vir/define-service
+ * @package [`@rest-vir/define-service`](https://www.npmjs.com/package/@rest-vir/define-service)
+ */
+export declare class ServiceDefinitionError extends Error {
+    name: string;
+    constructor({ serviceName, path, errorMessage, isEndpoint, isWebSocket, }: ServiceDefinitionErrorParams);
+}
+/**
+ * Ensures that the given error is a {@link ServiceDefinitionError} instance. If it's not, then a new
+ * {@link ServiceDefinitionError} is created with the given params.
+ *
+ * @category Internal
+ * @category Package : @rest-vir/define-service
+ * @package [`@rest-vir/define-service`](https://www.npmjs.com/package/@rest-vir/define-service)
+ */
+export declare function ensureServiceDefinitionError(error: unknown, params: Omit<ServiceDefinitionErrorParams, 'errorMessage'>): ServiceDefinitionError;

package/dist/service/service-definition.error.js

@@ -0,0 +1,34 @@
+import { ensureErrorClass, extractErrorMessage } from '@augment-vir/common';
+/**
+ * An error thrown by endpoint and service validation assertions.
+ *
+ * @category Internal
+ * @category Package : @rest-vir/define-service
+ * @package [`@rest-vir/define-service`](https://www.npmjs.com/package/@rest-vir/define-service)
+ */
+export class ServiceDefinitionError extends Error {
+    name = 'ServiceDefinitionError';
+    constructor({ serviceName, path, errorMessage, isEndpoint, isWebSocket, }) {
+        const serviceNameMessage = `Service '${String(serviceName)}'`;
+        const routeType = isEndpoint ? 'Endpoint' : isWebSocket ? 'WebSocket' : undefined;
+        const nameMessage = path && routeType
+            ? `${routeType} '${path}' on ${serviceNameMessage}`
+            : serviceNameMessage;
+        const fullErrorMessage = `Failed to define ${nameMessage}: ${errorMessage}`;
+        super(fullErrorMessage);
+    }
+}
+/**
+ * Ensures that the given error is a {@link ServiceDefinitionError} instance. If it's not, then a new
+ * {@link ServiceDefinitionError} is created with the given params.
+ *
+ * @category Internal
+ * @category Package : @rest-vir/define-service
+ * @package [`@rest-vir/define-service`](https://www.npmjs.com/package/@rest-vir/define-service)
+ */
+export function ensureServiceDefinitionError(error, params) {
+    return ensureErrorClass(error, ServiceDefinitionError, {
+        ...params,
+        errorMessage: extractErrorMessage(error),
+    });
+}

package/dist/service/service-definition.js

@@ -0,0 +1 @@
+export {};

package/dist/util/mock-fetch.d.ts

@@ -0,0 +1,107 @@
+import { HttpStatus, type Overwrite, type PartialWithUndefined } from '@augment-vir/common';
+import { type IsNever } from 'type-fest';
+import { type EndpointDefinition } from '../endpoint/endpoint.js';
+/**
+ * Options for {@link createMockEndpointResponse} and {@link createMockEndpointFetch}.
+ *
+ * @category Internal
+ * @category Package : @rest-vir/define-service
+ * @package [`@rest-vir/define-service`](https://www.npmjs.com/package/@rest-vir/define-service)
+ */
+export type MockEndpointResponseOptions<EndpointToMock extends EndpointDefinition> = Overwrite<MockResponseParams, IsNever<Extract<EndpointToMock['ResponseType'], undefined>> extends true ? {
+    body: EndpointToMock['ResponseType'];
+} : {
+    body?: EndpointToMock['ResponseType'];
+}>;
+/**
+ * Creates a mocked fetch `Response` object for the given endpoint (requiring a type safe body). For
+ * more generic response mocking, see {@link createMockResponse}.
+ *
+ * @category Testing : Client (Frontend)
+ * @category Package : @rest-vir/define-service
+ * @package [`@rest-vir/define-service`](https://www.npmjs.com/package/@rest-vir/define-service)
+ */
+export declare function createMockEndpointResponse<const EndpointToMock extends EndpointDefinition>(endpoint: EndpointToMock, params: Readonly<MockEndpointResponseOptions<EndpointToMock>>): Response;
+/**
+ * Parameters for {@link createMockResponse}.
+ *
+ * @category Internal
+ * @category Package : @rest-vir/define-service
+ * @package [`@rest-vir/define-service`](https://www.npmjs.com/package/@rest-vir/define-service)
+ */
+export type MockResponseParams = Overwrite<Partial<Pick<Response, 'redirected' | 'statusText' | 'type'>>, PartialWithUndefined<{
+    status: HttpStatus;
+    url: string | URL;
+    headers: HeadersInit;
+    body: unknown;
+}>>;
+/**
+ * A `ReadableStream` implementation used by {@link createMockResponse} to create its streamed `body`
+ * property.
+ *
+ * @category Internal
+ * @category Package : @rest-vir/define-service
+ * @package [`@rest-vir/define-service`](https://www.npmjs.com/package/@rest-vir/define-service)
+ */
+export declare class MockResponseBodyStream extends ReadableStream<Uint8Array> {
+    private getReaderCalled;
+    constructor(body: unknown, getReaderCalled: () => void);
+    getReader(...args: any): any;
+}
+/**
+ * Creates a mocked, but realistic, `Response` object. Use this when mocking `fetch`. See
+ * {@link createMockEndpointResponse} for a more type safe version, specific to individual
+ * endpoints.
+ *
+ * @category Internal
+ * @category Package : @rest-vir/define-service
+ * @package [`@rest-vir/define-service`](https://www.npmjs.com/package/@rest-vir/define-service)
+ */
+export declare function createMockResponse(params?: Readonly<MockResponseParams>): Response;
+/**
+ * Creates a mock `fetch` function that returns a mock `Response` object that matches the
+ * expectations of the given endpoint. For more generic `fetch` mocking, see
+ * {@link createMockFetch}.
+ *
+ * @category Testing : Client (Frontend)
+ * @category Package : @rest-vir/define-service
+ * @example
+ *
+ * ```ts
+ * import {createMockEndpointFetch, fetchEndpoint} from '@rest-vir/define-service';
+ *
+ * fetchEndpoint(myService.endpoints['/my-path'], {
+ *     fetch: createMockEndpointFetch(myService.endpoints['/my-path'], {
+ *         body: 'some body',
+ *         // there are other properties that can be mocked as well, see the types for more details
+ *     }),
+ * });
+ * ```
+ *
+ * @package [`@rest-vir/define-service`](https://www.npmjs.com/package/@rest-vir/define-service)
+ */
+export declare function createMockEndpointFetch<const EndpointToMock extends EndpointDefinition>(endpoint: EndpointToMock, params: Readonly<Omit<MockEndpointResponseOptions<EndpointToMock>, 'url'>>): typeof globalThis.fetch;
+/**
+ * Creates a mock `fetch` function that always returns a mock `Response` object based on the given
+ * response parameters. For more control over a mocked `fetch`, use {@link createMockResponse}
+ * directly. See {@link createMockEndpointFetch} for a more type safe version, specific to individual
+ * endpoints.
+ *
+ * @category Internal
+ * @category Package : @rest-vir/define-service
+ * @example
+ *
+ * ```ts
+ * import {createMockFetch, fetchEndpoint} from '@rest-vir/define-service';
+ *
+ * fetchEndpoint(myService.endpoints['/my-path'], {
+ *     fetch: createMockFetch({
+ *         body: 'some body',
+ *         // there are other properties that can be mocked as well, see the types for more details
+ *     }),
+ * });
+ * ```
+ *
+ * @package [`@rest-vir/define-service`](https://www.npmjs.com/package/@rest-vir/define-service)
+ */
+export declare function createMockFetch(params?: Readonly<Omit<MockResponseParams, 'url'>>): typeof globalThis.fetch;

package/dist/util/mock-fetch.js

@@ -0,0 +1,199 @@
+import { check } from '@augment-vir/assert';
+import { copyThroughJson, HttpStatus, isErrorHttpStatus, } from '@augment-vir/common';
+/**
+ * Creates a mocked fetch `Response` object for the given endpoint (requiring a type safe body). For
+ * more generic response mocking, see {@link createMockResponse}.
+ *
+ * @category Testing : Client (Frontend)
+ * @category Package : @rest-vir/define-service
+ * @package [`@rest-vir/define-service`](https://www.npmjs.com/package/@rest-vir/define-service)
+ */
+export function createMockEndpointResponse(endpoint, params) {
+    return createMockResponse(params);
+}
+/**
+ * A `ReadableStream` implementation used by {@link createMockResponse} to create its streamed `body`
+ * property.
+ *
+ * @category Internal
+ * @category Package : @rest-vir/define-service
+ * @package [`@rest-vir/define-service`](https://www.npmjs.com/package/@rest-vir/define-service)
+ */
+export class MockResponseBodyStream extends ReadableStream {
+    getReaderCalled;
+    constructor(body, getReaderCalled) {
+        super({
+            start(controller) {
+                if (body instanceof Uint8Array) {
+                    controller.enqueue(body);
+                }
+                else if (check.isString(body)) {
+                    controller.enqueue(new TextEncoder().encode(body));
+                }
+                else if (body) {
+                    controller.enqueue(new TextEncoder().encode(JSON.stringify(body)));
+                }
+                controller.close();
+            },
+        });
+        this.getReaderCalled = getReaderCalled;
+    }
+    getReader(...args) {
+        this.getReaderCalled();
+        return super.getReader(...args);
+    }
+}
+/**
+ * Creates a mocked, but realistic, `Response` object. Use this when mocking `fetch`. See
+ * {@link createMockEndpointResponse} for a more type safe version, specific to individual
+ * endpoints.
+ *
+ * @category Internal
+ * @category Package : @rest-vir/define-service
+ * @package [`@rest-vir/define-service`](https://www.npmjs.com/package/@rest-vir/define-service)
+ */
+export function createMockResponse(params = {}) {
+    const { headers = [], status = HttpStatus.Ok, url = '', redirected, statusText = '', type = 'basic', body, } = params;
+    function createArrayBuffer() {
+        return check.instanceOf(body, ArrayBuffer)
+            ? body
+            : new TextEncoder().encode(typeof body === 'string' ? body : JSON.stringify(body))
+                .buffer;
+    }
+    let bodyUsed = false;
+    return {
+        headers: new Headers(headers),
+        ok: !isErrorHttpStatus(status),
+        body: new MockResponseBodyStream(body, () => {
+            if (bodyUsed) {
+                throw new TypeError('Body is disturbed or locked.');
+            }
+            bodyUsed = true;
+        }),
+        get bodyUsed() {
+            return bodyUsed;
+        },
+        status,
+        arrayBuffer() {
+            if (bodyUsed) {
+                throw new TypeError('Body is disturbed or locked.');
+            }
+            bodyUsed = true;
+            return Promise.resolve(createArrayBuffer());
+        },
+        blob() {
+            if (bodyUsed) {
+                throw new TypeError('Body is disturbed or locked.');
+            }
+            bodyUsed = true;
+            return Promise.resolve(new Blob([createArrayBuffer()]));
+        },
+        bytes() {
+            if (bodyUsed) {
+                throw new TypeError('Body is disturbed or locked.');
+            }
+            bodyUsed = true;
+            return Promise.resolve(check.instanceOf(body, Uint8Array) ? body : new Uint8Array(createArrayBuffer()));
+        },
+        formData() {
+            if (bodyUsed) {
+                throw new TypeError('Body is disturbed or locked.');
+            }
+            bodyUsed = true;
+            const formData = new FormData();
+            if (check.isObject(body)) {
+                Object.entries(body).forEach(([key, value,]) => {
+                    formData.append(key, check.isString(value)
+                        ? value
+                        : check.instanceOf(value, Blob)
+                            ? value
+                            : JSON.stringify(value));
+                });
+            }
+            return Promise.resolve(formData);
+        },
+        text() {
+            if (bodyUsed) {
+                throw new TypeError('Body is disturbed or locked.');
+            }
+            bodyUsed = true;
+            return Promise.resolve(check.isString(body) ? body : JSON.stringify(body));
+        },
+        json() {
+            if (bodyUsed) {
+                throw new TypeError('Body is disturbed or locked.');
+            }
+            bodyUsed = true;
+            return Promise.resolve(check.isString(body) ? JSON.parse(body) : copyThroughJson(body));
+        },
+        url: String(url),
+        redirected: !!redirected,
+        statusText,
+        type,
+        clone() {
+            return createMockResponse(params);
+        },
+    };
+}
+/**
+ * Creates a mock `fetch` function that returns a mock `Response` object that matches the
+ * expectations of the given endpoint. For more generic `fetch` mocking, see
+ * {@link createMockFetch}.
+ *
+ * @category Testing : Client (Frontend)
+ * @category Package : @rest-vir/define-service
+ * @example
+ *
+ * ```ts
+ * import {createMockEndpointFetch, fetchEndpoint} from '@rest-vir/define-service';
+ *
+ * fetchEndpoint(myService.endpoints['/my-path'], {
+ *     fetch: createMockEndpointFetch(myService.endpoints['/my-path'], {
+ *         body: 'some body',
+ *         // there are other properties that can be mocked as well, see the types for more details
+ *     }),
+ * });
+ * ```
+ *
+ * @package [`@rest-vir/define-service`](https://www.npmjs.com/package/@rest-vir/define-service)
+ */
+export function createMockEndpointFetch(endpoint, params) {
+    return createMockFetch(params);
+}
+/**
+ * Creates a mock `fetch` function that always returns a mock `Response` object based on the given
+ * response parameters. For more control over a mocked `fetch`, use {@link createMockResponse}
+ * directly. See {@link createMockEndpointFetch} for a more type safe version, specific to individual
+ * endpoints.
+ *
+ * @category Internal
+ * @category Package : @rest-vir/define-service
+ * @example
+ *
+ * ```ts
+ * import {createMockFetch, fetchEndpoint} from '@rest-vir/define-service';
+ *
+ * fetchEndpoint(myService.endpoints['/my-path'], {
+ *     fetch: createMockFetch({
+ *         body: 'some body',
+ *         // there are other properties that can be mocked as well, see the types for more details
+ *     }),
+ * });
+ * ```
+ *
+ * @package [`@rest-vir/define-service`](https://www.npmjs.com/package/@rest-vir/define-service)
+ */
+export function createMockFetch(params = {}) {
+    return (...args) => {
+        const url = check.instanceOf(args[0], URL)
+            ? args[0].toString()
+            : check.isString(args[0])
+                ? args[0]
+                : args[0].url;
+        const mockResponse = createMockResponse({
+            ...params,
+            url,
+        });
+        return Promise.resolve(mockResponse);
+    };
+}

package/dist/util/no-param.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Runtime value for {@link NoParam}.
+ *
+ * @category Internal
+ * @category Package : @rest-vir/define-service
+ * @package [`@rest-vir/define-service`](https://www.npmjs.com/package/@rest-vir/define-service)
+ */
+export declare const NoParam: unique symbol;
+/**
+ * Use to keep track of type parameters that are generic and haven't received a specific type yet.
+ *
+ * @category Internal
+ * @category Package : @rest-vir/define-service
+ * @package [`@rest-vir/define-service`](https://www.npmjs.com/package/@rest-vir/define-service)
+ */
+export type NoParam = typeof NoParam;

package/dist/util/no-param.js

@@ -0,0 +1,8 @@
+/**
+ * Runtime value for {@link NoParam}.
+ *
+ * @category Internal
+ * @category Package : @rest-vir/define-service
+ * @package [`@rest-vir/define-service`](https://www.npmjs.com/package/@rest-vir/define-service)
+ */
+export const NoParam = Symbol('no type parameter');

package/dist/util/origin.d.ts

@@ -0,0 +1,43 @@
+import { MaybePromise } from '@augment-vir/common';
+/**
+ * Explicity denotes that any origin is allowed.
+ *
+ * @category Internal
+ * @category Package : @rest-vir/define-service
+ * @package [`@rest-vir/define-service`](https://www.npmjs.com/package/@rest-vir/define-service)
+ */
+export declare const AnyOrigin: unique symbol;
+/**
+ * Type for {@link AnyOrigin} symbol.
+ *
+ * @category Internal
+ * @category Package : @rest-vir/define-service
+ * @package [`@rest-vir/define-service`](https://www.npmjs.com/package/@rest-vir/define-service)
+ */
+export type AnyOrigin = typeof AnyOrigin;
+/**
+ * Options explained:
+ *
+ * - `undefined`: when on an endpoint, this denotes that the endpoint defers origin checks to the
+ *   parent service's origin requirement. When on the service, `undefined` is not allowed.
+ * - `string`: require all request origins to exactly match the given string.
+ * - `RegExp`: all request origins must match the RegExp.
+ * - {@link AnyOrigin}: allow any origin.
+ * - A function: allow custom checking. If this function returns something truthy, the origin is
+ *   allowed.
+ * - An array: a combination of `string` values, `RegExp` values, or functions to compare against. If
+ *   any of the array entries allow a request origin, it passes.
+ *
+ * @category Internal
+ * @category Package : @rest-vir/define-service
+ * @package [`@rest-vir/define-service`](https://www.npmjs.com/package/@rest-vir/define-service)
+ */
+export type OriginRequirement = undefined | string | RegExp | AnyOrigin | (((origin: string | undefined) => MaybePromise<boolean>) | string | RegExp)[] | ((origin: string | undefined) => MaybePromise<boolean>);
+/**
+ * Shape definition for {@link OriginRequirement}.
+ *
+ * @category Internal
+ * @category Package : @rest-vir/define-service
+ * @package [`@rest-vir/define-service`](https://www.npmjs.com/package/@rest-vir/define-service)
+ */
+export declare const originRequirementShape: import("object-shape-tester").ShapeOr<[undefined, string, import("object-shape-tester").ShapeClass<[RegExpConstructor]>, () => void, import("object-shape-tester").ShapeOr<[string, import("object-shape-tester").ShapeClass<[RegExpConstructor]>, () => void]>[]]>;

package/dist/util/origin.js

@@ -0,0 +1,19 @@
+import { classShape, or } from 'object-shape-tester';
+/**
+ * Explicity denotes that any origin is allowed.
+ *
+ * @category Internal
+ * @category Package : @rest-vir/define-service
+ * @package [`@rest-vir/define-service`](https://www.npmjs.com/package/@rest-vir/define-service)
+ */
+export const AnyOrigin = Symbol('any-origin');
+/**
+ * Shape definition for {@link OriginRequirement}.
+ *
+ * @category Internal
+ * @category Package : @rest-vir/define-service
+ * @package [`@rest-vir/define-service`](https://www.npmjs.com/package/@rest-vir/define-service)
+ */
+export const originRequirementShape = or(undefined, '', classShape(RegExp), () => { }, [
+    or('', classShape(RegExp), () => { }),
+]);

package/dist/util/path-to-regexp.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Generic parameter data for {@link MatchResult}.
+ *
+ * This is from the [path-to-regexp](https://www.npmjs.com/package/path-to-regexp) package.
+ *
+ * @category Internal
+ * @category Package : @rest-vir/define-service
+ * @package [`@rest-vir/define-service`](https://www.npmjs.com/package/@rest-vir/define-service)
+ */
+export type ParamData = Partial<Record<string, string | string[]>>;
+/**
+ * A match result that contains data about the path match. Used in {@link Match}
+ *
+ * This is from the [path-to-regexp](https://www.npmjs.com/package/path-to-regexp) package.
+ *
+ * @category Internal
+ * @category Package : @rest-vir/define-service
+ * @package [`@rest-vir/define-service`](https://www.npmjs.com/package/@rest-vir/define-service)
+ */
+export type MatchResult = {
+    path: string;
+    params: ParamData;
+};
+/**
+ * A match is either `false` (no match) or a match result.
+ *
+ * This is from the [path-to-regexp](https://www.npmjs.com/package/path-to-regexp) package.
+ *
+ * @category Internal
+ * @category Package : @rest-vir/define-service
+ * @package [`@rest-vir/define-service`](https://www.npmjs.com/package/@rest-vir/define-service)
+ */
+export type Match = false | MatchResult;
+/**
+ * A match function that takes a string and returns whether it matched the path. Used in
+ * {@link match}.
+ *
+ * This is from the [path-to-regexp](https://www.npmjs.com/package/path-to-regexp) package.
+ *
+ * @category Internal
+ * @category Package : @rest-vir/define-service
+ * @package [`@rest-vir/define-service`](https://www.npmjs.com/package/@rest-vir/define-service)
+ */
+export type MatchFunction = (path: string) => Match;
+/**
+ * Transform a path into a match function.
+ *
+ * This is from the [path-to-regexp](https://www.npmjs.com/package/path-to-regexp) package.
+ *
+ * @category Internal
+ * @category Package : @rest-vir/define-service
+ * @package [`@rest-vir/define-service`](https://www.npmjs.com/package/@rest-vir/define-service)
+ */
+export declare function match(path: string): MatchFunction;