@sapporta/rest-core 3.52.1 → 3.52.2

package/index.cjs.js

@@ -0,0 +1,807 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+/**
+ * The error class for standard schema validation errors.
+ *
+ * @see {@link StandardSchemaV1.FailureResult}
+ */
+class StandardSchemaError extends Error {
+    constructor(issues) {
+        /**
+         * Similar pattern to ZodError regarding bigints.
+         */
+        const message = JSON.stringify(issues, (_, value) => (typeof value === 'bigint' ? value.toString() : value), 2);
+        super(message);
+        this.name = 'ValidationError';
+        this.issues = issues;
+    }
+    /*
+      ZodError overrides the toString method to return the serialised message.
+      The Next.js implementation relies on this behaviour.
+    */
+    toString() {
+        return this.message;
+    }
+}
+
+const VENDOR_STANDARD_SCHEMA = 'ts-rest-combined';
+/**
+ * Type guard to check if the schema is a standard schema.
+ *
+ * @param schema - unknown
+ * @returns boolean
+ */
+const isStandardSchema = (schema) => {
+    if (!schema) {
+        return false;
+    }
+    const standard = schema === null || schema === void 0 ? void 0 : schema['~standard'];
+    if (!standard) {
+        return false;
+    }
+    return standard.version === 1 && typeof standard.validate === 'function';
+};
+/**
+ * Takes in an unknown object and returns either a standard schema or null
+ *
+ * @param schema - unknown
+ * @returns StandardSchemaV1<unknown, unknown> | null
+ */
+const parseAsStandardSchema = (schema) => {
+    const isStandard = isStandardSchema(schema);
+    if (isStandard) {
+        return schema;
+    }
+    return null;
+};
+/**
+ * Since 3.53.0 we've moved to headers using an object with schemas inside it, rather than a top level schema.
+ *
+ * This makes it easier to merge schemas together.
+ *
+ * @param data - Data to validate e.g. headers
+ * @param schemaObject - Schema object to validate against e.g. { 'x-foo': v.string() }
+ * @returns
+ */
+const validateMultiSchemaObject = (data, schemaObject) => {
+    const schema = parseAsStandardSchema(schemaObject);
+    // If the top level is not null we know it's a valid schema we can validate against
+    if (schema !== null) {
+        const result = validateAgainstStandardSchema(data, schema, {
+            passThroughExtraKeys: true,
+        });
+        return {
+            value: result.value,
+            error: result.error,
+            schemasUsed: [schema],
+        };
+    }
+    const headersMap = new Map(Object.entries(data !== null && data !== void 0 ? data : {}));
+    const vendorSet = new Set();
+    const subSchemas = new Map();
+    for (const [key, schema] of Object.entries(schemaObject !== null && schemaObject !== void 0 ? schemaObject : {})) {
+        const parsedSchema = parseAsStandardSchema(schema);
+        if (schema === null) {
+            continue;
+        }
+        if (typeof schema === 'symbol') {
+            continue;
+        }
+        if (parsedSchema !== null) {
+            subSchemas.set(key, parsedSchema);
+            vendorSet.add(parsedSchema['~standard'].vendor);
+        }
+        else {
+            throw new Error(`Invalid schema provided for header ${key}, please use a valid schema`);
+        }
+    }
+    if (subSchemas.size === 0) {
+        return {
+            value: data,
+            schemasUsed: [],
+        };
+    }
+    const issues = [];
+    for (const [key, schema] of subSchemas.entries()) {
+        const value = headersMap.get(key);
+        const result = validateAgainstStandardSchema(value, schema);
+        if (result.error) {
+            for (const issue of result.error.issues) {
+                issues.push({
+                    ...issue,
+                    path: [key],
+                });
+            }
+        }
+        else {
+            headersMap.set(key, result.value);
+        }
+    }
+    if (issues.length > 0) {
+        return {
+            error: new StandardSchemaError(issues),
+            schemasUsed: [...subSchemas.values()],
+        };
+    }
+    return {
+        value: Object.fromEntries(headersMap.entries()),
+        schemasUsed: [...subSchemas.values()],
+    };
+};
+/**
+ * Combines two standard schemas into a single standard schema.
+ *
+ * The combined schema will run the validation of both schemas and return the result of the first schema that
+ * succeeds.
+ *
+ * If either schema fails, the combined schema will return the issues from both schemas.
+ *
+ * @param a - StandardSchemaV1<unknown, unknown>
+ * @param b - StandardSchemaV1<unknown, unknown>
+ * @returns StandardSchemaV1<unknown, unknown>
+ */
+const combineStandardSchemas = (a, b) => {
+    const standardSchema = {
+        vendor: VENDOR_STANDARD_SCHEMA,
+        version: 1,
+        validate: (input) => {
+            const result = a['~standard'].validate(input);
+            const result2 = b['~standard'].validate(input);
+            if (result instanceof Promise || result2 instanceof Promise) {
+                throw new Error('Schema validation must be synchronous');
+            }
+            // TODO: Agree on the behavior of this for standard schemas
+            if (result.issues || result2.issues) {
+                return {
+                    issues: [...(result.issues || []), ...(result2.issues || [])],
+                };
+            }
+            return {
+                value: {
+                    ...(result.value || {}),
+                    ...(result2.value || {}),
+                },
+            };
+        },
+    };
+    return {
+        '~standard': standardSchema,
+    };
+};
+/**
+ * Merges two header schemas together, these can either be legacy zod objects or objects containing standard schemas.
+ */
+const mergeHeaderSchemasForRoute = (baseSchema, routeSchema) => {
+    if (!baseSchema) {
+        return routeSchema;
+    }
+    if (!routeSchema) {
+        return baseSchema;
+    }
+    const mergedObjects = {
+        ...baseSchema,
+        ...routeSchema,
+    };
+    return mergedObjects;
+};
+/**
+ * Similar to validateAgainstStandardSchema, but it takes an unknown schema, it will not validate if no schema provided and will check the schema is
+ * valid before validating the data.
+ *
+ * This is super handy for validating request bodies, headers, etc. as it passes through the data if no schema is provided.
+ */
+const validateIfSchema = (data, schema, { passThroughExtraKeys = false, } = {}) => {
+    const schemaStandard = parseAsStandardSchema(schema);
+    if (!schemaStandard) {
+        return { value: data, schemasUsed: [] };
+    }
+    const result = validateAgainstStandardSchema(data, schemaStandard, {
+        passThroughExtraKeys,
+    });
+    return {
+        ...result,
+        schemasUsed: [schemaStandard],
+    };
+};
+const validateAgainstStandardSchema = (data, schema, { passThroughExtraKeys = false, } = {}) => {
+    const result = schema['~standard'].validate(data);
+    if (result instanceof Promise) {
+        throw new Error('Schema validation must be synchronous');
+    }
+    if (result.issues) {
+        return {
+            error: new StandardSchemaError(result.issues),
+        };
+    }
+    if (passThroughExtraKeys && typeof data === 'object' && result.value) {
+        return {
+            value: { ...data, ...result.value },
+        };
+    }
+    return {
+        value: result.value,
+    };
+};
+
+const ContractNoBody = Symbol('ContractNoBody');
+/**
+ * Differentiate between a route and a router
+ *
+ * @param obj
+ * @returns
+ */
+const isAppRoute = (obj) => {
+    return 'method' in obj && 'path' in obj;
+};
+const isAppRouteQuery = (route) => {
+    return route.method === 'GET';
+};
+const isAppRouteMutation = (route) => {
+    return !isAppRouteQuery(route);
+};
+/**
+ *
+ * @deprecated Please use {@link initContract} instead.
+ */
+const initTsRest = () => initContract();
+const recursivelyApplyOptions = (router, options) => {
+    return Object.fromEntries(Object.entries(router).map(([key, value]) => {
+        var _a, _b, _c;
+        if (isAppRoute(value)) {
+            return [
+                key,
+                {
+                    ...value,
+                    path: (options === null || options === void 0 ? void 0 : options.pathPrefix)
+                        ? options.pathPrefix + value.path
+                        : value.path,
+                    headers: mergeHeaderSchemasForRoute(options === null || options === void 0 ? void 0 : options.baseHeaders, value.headers),
+                    strictStatusCodes: (_a = value.strictStatusCodes) !== null && _a !== void 0 ? _a : options === null || options === void 0 ? void 0 : options.strictStatusCodes,
+                    validateResponseOnClient: (_b = value.validateResponseOnClient) !== null && _b !== void 0 ? _b : options === null || options === void 0 ? void 0 : options.validateResponseOnClient,
+                    responses: {
+                        ...options === null || options === void 0 ? void 0 : options.commonResponses,
+                        ...value.responses,
+                    },
+                    metadata: (options === null || options === void 0 ? void 0 : options.metadata)
+                        ? {
+                            ...options === null || options === void 0 ? void 0 : options.metadata,
+                            ...((_c = value.metadata) !== null && _c !== void 0 ? _c : {}),
+                        }
+                        : value.metadata,
+                },
+            ];
+        }
+        else {
+            return [key, recursivelyApplyOptions(value, options)];
+        }
+    }));
+};
+const ContractPlainTypeRuntimeSymbol = Symbol('ContractPlainType');
+/**
+ * Instantiate a ts-rest client, primarily to access `router`, `response`, and `body`
+ *
+ * @returns {ContractInstance}
+ */
+const initContract = () => {
+    return {
+        // @ts-expect-error - this is a type error, but it's not clear how to fix it
+        router: (endpoints, options) => recursivelyApplyOptions(endpoints, options),
+        query: (args) => args,
+        mutation: (args) => args,
+        responses: (args) => args,
+        response: () => ContractPlainTypeRuntimeSymbol,
+        body: () => ContractPlainTypeRuntimeSymbol,
+        type: () => ContractPlainTypeRuntimeSymbol,
+        otherResponse: ({ contentType, body, }) => ({
+            contentType,
+            body,
+        }),
+        noBody: () => ContractNoBody,
+    };
+};
+
+/**
+ * @param path - The URL e.g. /posts/:id
+ * @param params - The params e.g. `{ id: string }`
+ * @returns - The URL with the params e.g. /posts/123
+ */
+const insertParamsIntoPath = ({ path, params, }) => {
+    const pathParams = params;
+    return path.replace(/\/?:([^/?]+)\??/g, (matched, p) => pathParams[p]
+        ? `${matched.startsWith('/') ? '/' : ''}${pathParams[p]}`
+        : '');
+};
+
+/**
+ *
+ * @param query - Any JSON object
+ * @param json - Use JSON.stringify to encode the query values
+ * @returns - The query url segment, using explode array syntax, and deep object syntax
+ */
+const convertQueryParamsToUrlString = (query, json = false) => {
+    const queryString = json
+        ? encodeQueryParamsJson(query)
+        : encodeQueryParams(query);
+    return (queryString === null || queryString === void 0 ? void 0 : queryString.length) > 0 ? '?' + queryString : '';
+};
+const encodeQueryParamsJson = (query) => {
+    if (!query) {
+        return '';
+    }
+    return Object.entries(query)
+        .filter(([, value]) => value !== undefined)
+        .map(([key, value]) => {
+        let encodedValue;
+        // if value is a string and is not a reserved JSON value or a number, pass it without encoding
+        // this makes strings look nicer in the URL (e.g. ?name=John instead of ?name=%22John%22)
+        // this is also how OpenAPI will pass strings even if they are marked as application/json types
+        if (typeof value === 'string' &&
+            !['true', 'false', 'null'].includes(value.trim()) &&
+            isNaN(Number(value))) {
+            encodedValue = value;
+        }
+        else {
+            encodedValue = JSON.stringify(value);
+        }
+        return `${encodeURIComponent(key)}=${encodeURIComponent(encodedValue)}`;
+    })
+        .join('&');
+};
+const encodeQueryParams = (query) => {
+    if (!query) {
+        return '';
+    }
+    return (Object.keys(query)
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore
+        .flatMap((key) => tokeniseValue(key, query[key]))
+        .map(([key, value]) => {
+        return `${encodeURIComponent(key)}=${encodeURIComponent(value)}`;
+    })
+        .join('&'));
+};
+/**
+ * A recursive function to convert an object/string/number/Date/whatever into an array of key=value pairs
+ *
+ * The output of this should be flatMap-able to a string of key=value pairs which can be
+ * joined with & to form a query string
+ *
+ * This should be fully compatible with the "qs" library, but without the need to add a dependency
+ */
+const tokeniseValue = (key, value) => {
+    if (Array.isArray(value)) {
+        return value.flatMap((v, idx) => tokeniseValue(`${key}[${idx}]`, v));
+    }
+    if (value instanceof Date) {
+        return [[`${key}`, value.toISOString()]];
+    }
+    if (value === null) {
+        return [[`${key}`, '']];
+    }
+    if (value === undefined) {
+        return [];
+    }
+    if (typeof value === 'object') {
+        return Object.keys(value).flatMap((k) => 
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore
+        tokeniseValue(`${key}[${k}]`, value[k]));
+    }
+    return [[`${key}`, `${value}`]];
+};
+/**
+ *
+ * @param query - A server-side query object where values have been encoded as JSON strings
+ * @returns - The same object with the JSON strings decoded. Objects that were encoded using toJSON such as Dates will remain as strings
+ */
+const parseJsonQueryObject = (query) => {
+    return Object.fromEntries(Object.entries(query).map(([key, value]) => {
+        let parsedValue;
+        // if json parse fails, treat the value as a string
+        // this allows us to pass strings without having to surround them with quotes
+        try {
+            parsedValue = JSON.parse(value);
+        }
+        catch {
+            parsedValue = value;
+        }
+        return [key, parsedValue];
+    }));
+};
+
+class UnknownStatusError extends Error {
+    constructor(response, knownResponseStatuses) {
+        const expectedStatuses = knownResponseStatuses.join(',');
+        super(`Server returned unexpected response. Expected one of: ${expectedStatuses} got: ${response.status}`);
+        this.response = response;
+    }
+}
+
+/**
+ * @deprecated Only safe to use on the client-side. Use `ServerInferResponses`/`ClientInferResponses` instead.
+ */
+function getRouteResponses(router) {
+    return {};
+}
+/**
+ * Default fetch api implementation:
+ *
+ * Can be used as a reference for implementing your own fetcher,
+ * or used in the "api" field of ClientArgs to allow you to hook
+ * into the request to run custom logic
+ */
+const tsRestFetchApi = async ({ route, path, method, headers, body, validateResponse, fetchOptions, }) => {
+    const result = await fetch(path, {
+        ...fetchOptions,
+        method,
+        headers,
+        body,
+    });
+    const contentType = result.headers.get('content-type');
+    if ((contentType === null || contentType === void 0 ? void 0 : contentType.includes('application/')) && (contentType === null || contentType === void 0 ? void 0 : contentType.includes('json'))) {
+        const responseSchema = route.responses[result.status];
+        const response = {
+            status: result.status,
+            body: responseSchema === ContractNoBody ? undefined : await result.json(),
+            headers: result.headers,
+        };
+        const responseSchemaStandard = parseAsStandardSchema(responseSchema);
+        if (responseSchemaStandard &&
+            (validateResponse !== null && validateResponse !== void 0 ? validateResponse : route.validateResponseOnClient)) {
+            const result = validateAgainstStandardSchema(response.body, responseSchemaStandard);
+            if (result.error) {
+                throw result.error;
+            }
+            return {
+                ...response,
+                body: result.value,
+            };
+        }
+        return response;
+    }
+    if (contentType === null || contentType === void 0 ? void 0 : contentType.includes('text/')) {
+        return {
+            status: result.status,
+            body: await result.text(),
+            headers: result.headers,
+        };
+    }
+    return {
+        status: result.status,
+        body: await result.blob(),
+        headers: result.headers,
+    };
+};
+const createFormData = (body) => {
+    const formData = new FormData();
+    const appendToFormData = (key, value) => {
+        if (value instanceof File) {
+            formData.append(key, value);
+        }
+        else {
+            formData.append(key, JSON.stringify(value));
+        }
+    };
+    Object.entries(body).forEach(([key, value]) => {
+        if (Array.isArray(value)) {
+            for (const item of value) {
+                appendToFormData(key, item);
+            }
+        }
+        else {
+            appendToFormData(key, value);
+        }
+    });
+    return formData;
+};
+const normalizeHeaders = (headers) => {
+    return Object.fromEntries(Object.entries(headers).map(([k, v]) => [k.toLowerCase(), v]));
+};
+const fetchApi = (options) => {
+    const { path, clientArgs, route, body, query, extraInputArgs, headers, fetchOptions, } = options;
+    const apiFetcher = clientArgs.api || tsRestFetchApi;
+    const baseHeaders = clientArgs.baseHeaders &&
+        Object.fromEntries(Object.entries(clientArgs.baseHeaders).map(([name, valueOrFunction]) => {
+            if (typeof valueOrFunction === 'function') {
+                return [name, valueOrFunction(options)];
+            }
+            else {
+                return [name, valueOrFunction];
+            }
+        }));
+    const combinedHeaders = {
+        ...(baseHeaders && normalizeHeaders(baseHeaders)),
+        ...normalizeHeaders(headers),
+    };
+    // Remove any headers that are set to undefined
+    Object.keys(combinedHeaders).forEach((key) => {
+        if (combinedHeaders[key] === undefined) {
+            delete combinedHeaders[key];
+        }
+    });
+    let fetcherArgs = {
+        route,
+        path,
+        method: route.method,
+        headers: combinedHeaders,
+        body: undefined,
+        rawBody: body,
+        rawQuery: query,
+        contentType: undefined,
+        validateResponse: clientArgs.validateResponse,
+        fetchOptions: {
+            ...(clientArgs.credentials && { credentials: clientArgs.credentials }),
+            ...fetchOptions,
+        },
+        ...((fetchOptions === null || fetchOptions === void 0 ? void 0 : fetchOptions.signal) && { signal: fetchOptions.signal }),
+        ...((fetchOptions === null || fetchOptions === void 0 ? void 0 : fetchOptions.cache) && { cache: fetchOptions.cache }),
+        ...(fetchOptions &&
+            'next' in fetchOptions &&
+            !!(fetchOptions === null || fetchOptions === void 0 ? void 0 : fetchOptions.next) && { next: fetchOptions.next }),
+    };
+    if (route.method !== 'GET') {
+        if ('contentType' in route && route.contentType === 'multipart/form-data') {
+            fetcherArgs = {
+                ...fetcherArgs,
+                contentType: 'multipart/form-data',
+                body: body instanceof FormData ? body : createFormData(body),
+            };
+        }
+        else if ('contentType' in route &&
+            route.contentType === 'application/x-www-form-urlencoded') {
+            fetcherArgs = {
+                ...fetcherArgs,
+                contentType: 'application/x-www-form-urlencoded',
+                headers: {
+                    'content-type': 'application/x-www-form-urlencoded',
+                    ...fetcherArgs.headers,
+                },
+                body: typeof body === 'string'
+                    ? body
+                    : new URLSearchParams(body),
+            };
+        }
+        else if (body !== null && body !== undefined) {
+            fetcherArgs = {
+                ...fetcherArgs,
+                contentType: 'application/json',
+                headers: {
+                    'content-type': 'application/json',
+                    ...fetcherArgs.headers,
+                },
+                body: JSON.stringify(body),
+            };
+        }
+    }
+    return apiFetcher({
+        ...fetcherArgs,
+        ...extraInputArgs,
+    });
+};
+const evaluateFetchApiArgs = (route, clientArgs, inputArgs) => {
+    const { query, params, body, headers, extraHeaders, overrideClientOptions, fetchOptions, 
+    // TODO: remove in 4.0
+    cache, 
+    // TODO: remove in 4.0
+    next, 
+    // extra input args
+    ...extraInputArgs } = inputArgs || {};
+    const overriddenClientArgs = {
+        ...clientArgs,
+        ...overrideClientOptions,
+    };
+    /**
+     * Coerce params to strings, allowing for numbers to be passed in (e.g. from using z.coerce.number())
+     */
+    const parsedParams = typeof params === 'object'
+        ? Object.fromEntries(Object.entries(params).map(([key, value]) => [key, String(value)]))
+        : {};
+    const completeUrl = getCompleteUrl(query, overriddenClientArgs.baseUrl, parsedParams, route, !!overriddenClientArgs.jsonQuery);
+    return {
+        path: completeUrl,
+        clientArgs: overriddenClientArgs,
+        route,
+        body,
+        query,
+        extraInputArgs,
+        fetchOptions: {
+            ...(cache && { cache }),
+            ...(next && { next }),
+            ...fetchOptions,
+        },
+        headers: {
+            ...extraHeaders,
+            ...headers,
+        },
+    };
+};
+/**
+ * @hidden
+ */
+const getCompleteUrl = (query, baseUrl, params, route, jsonQuery) => {
+    const path = insertParamsIntoPath({
+        path: route.path,
+        params: params,
+    });
+    const queryComponent = convertQueryParamsToUrlString(query, jsonQuery);
+    if (baseUrl.endsWith('/') && path.startsWith('/')) {
+        return `${baseUrl}${path.substring(1)}${queryComponent}`;
+    }
+    return `${baseUrl}${path}${queryComponent}`;
+};
+const getRouteQuery = (route, clientArgs) => {
+    const knownResponseStatuses = Object.keys(route.responses);
+    return async (inputArgs) => {
+        const fetchApiArgs = evaluateFetchApiArgs(route, clientArgs, inputArgs);
+        const response = await fetchApi(fetchApiArgs);
+        // TODO: in next major version, throw by default if `strictStatusCode` is enabled
+        if (!clientArgs.throwOnUnknownStatus) {
+            return response;
+        }
+        if (knownResponseStatuses.includes(response.status.toString())) {
+            return response;
+        }
+        throw new UnknownStatusError(response, knownResponseStatuses);
+    };
+};
+const initClient = (router, args) => {
+    return Object.fromEntries(Object.entries(router).map(([key, subRouter]) => {
+        if (isAppRoute(subRouter)) {
+            return [key, getRouteQuery(subRouter, args)];
+        }
+        else {
+            return [key, initClient(subRouter, args)];
+        }
+    }));
+};
+
+class TsRestResponseValidationError extends Error {
+    constructor(appRoute, cause) {
+        super(`[ts-rest] Response validation failed for ${appRoute.method} ${appRoute.path}: ${cause.message}`);
+        this.appRoute = appRoute;
+        this.cause = cause;
+    }
+}
+class TsRestRequestValidationError extends Error {
+    constructor(pathParams, headers, query, body) {
+        super('[ts-rest] request validation failed');
+        this.pathParams = pathParams;
+        this.headers = headers;
+        this.query = query;
+        this.body = body;
+    }
+}
+
+const isAppRouteResponse = (value) => {
+    return (value != null &&
+        typeof value === 'object' &&
+        'status' in value &&
+        typeof value.status === 'number');
+};
+const isAppRouteOtherResponse = (response) => {
+    return (response != null &&
+        typeof response === 'object' &&
+        'contentType' in response);
+};
+const isAppRouteNoBody = (response) => {
+    return response === ContractNoBody;
+};
+const validateResponse = ({ appRoute, response, }) => {
+    if (isAppRouteResponse(response)) {
+        const responseType = appRoute.responses[response.status];
+        const responseSchema = isAppRouteOtherResponse(responseType)
+            ? responseType.body
+            : responseType;
+        const responseStandardSchema = parseAsStandardSchema(responseSchema);
+        const responseValidation = validateIfSchema(response.body, responseStandardSchema);
+        if (responseValidation.error) {
+            throw new TsRestResponseValidationError(appRoute, responseValidation.error);
+        }
+        return {
+            status: response.status,
+            body: responseValidation.value,
+        };
+    }
+    return response;
+};
+
+class TsRestResponseError extends Error {
+    constructor(route, response) {
+        super();
+        this.statusCode = response.status;
+        this.body = response.body;
+        this.name = this.constructor.name;
+        if (typeof response.body === 'string') {
+            this.message = response.body;
+        }
+        else if (typeof response.body === 'object' &&
+            response.body !== null &&
+            'message' in response.body &&
+            typeof response.body.message === 'string') {
+            this.message = response.body['message'];
+        }
+        else {
+            this.message = 'Error';
+        }
+    }
+}
+
+const isResponse = (response, contractEndpoint) => {
+    return (typeof response === 'object' &&
+        response !== null &&
+        'status' in response &&
+        'body' in response &&
+        typeof response.status === 'number' &&
+        response.status >= 200 &&
+        response.status < 600 &&
+        ((contractEndpoint === null || contractEndpoint === void 0 ? void 0 : contractEndpoint.strictStatusCodes)
+            ? Object.keys(contractEndpoint.responses).includes(response.status.toString())
+            : true));
+};
+const isSuccessResponse = (response, contractEndpoint) => {
+    return (isResponse(response, contractEndpoint) &&
+        response.status >= 200 &&
+        response.status < 300);
+};
+const isErrorResponse = (response, contractEndpoint) => {
+    return (isResponse(response, contractEndpoint) &&
+        !isSuccessResponse(response, contractEndpoint));
+};
+const isUnknownResponse = (response, contractEndpoint) => {
+    return (isResponse(response) &&
+        !Object.keys(contractEndpoint.responses).includes(response.status.toString()));
+};
+const isUnknownSuccessResponse = (response, contractEndpoint) => {
+    return (isSuccessResponse(response) && isUnknownResponse(response, contractEndpoint));
+};
+const isUnknownErrorResponse = (response, contractEndpoint) => {
+    return (isErrorResponse(response) && isUnknownResponse(response, contractEndpoint));
+};
+const exhaustiveGuard = (response) => {
+    throw new Error(`Unreachable code: Response status is ${response.status}`);
+};
+
+exports.ContractNoBody = ContractNoBody;
+exports.ContractPlainTypeRuntimeSymbol = ContractPlainTypeRuntimeSymbol;
+exports.StandardSchemaError = StandardSchemaError;
+exports.TsRestRequestValidationError = TsRestRequestValidationError;
+exports.TsRestResponseError = TsRestResponseError;
+exports.TsRestResponseValidationError = TsRestResponseValidationError;
+exports.UnknownStatusError = UnknownStatusError;
+exports.combineStandardSchemas = combineStandardSchemas;
+exports.convertQueryParamsToUrlString = convertQueryParamsToUrlString;
+exports.encodeQueryParams = encodeQueryParams;
+exports.encodeQueryParamsJson = encodeQueryParamsJson;
+exports.evaluateFetchApiArgs = evaluateFetchApiArgs;
+exports.exhaustiveGuard = exhaustiveGuard;
+exports.fetchApi = fetchApi;
+exports.getCompleteUrl = getCompleteUrl;
+exports.getRouteQuery = getRouteQuery;
+exports.getRouteResponses = getRouteResponses;
+exports.initClient = initClient;
+exports.initContract = initContract;
+exports.initTsRest = initTsRest;
+exports.insertParamsIntoPath = insertParamsIntoPath;
+exports.isAppRoute = isAppRoute;
+exports.isAppRouteMutation = isAppRouteMutation;
+exports.isAppRouteNoBody = isAppRouteNoBody;
+exports.isAppRouteOtherResponse = isAppRouteOtherResponse;
+exports.isAppRouteQuery = isAppRouteQuery;
+exports.isAppRouteResponse = isAppRouteResponse;
+exports.isErrorResponse = isErrorResponse;
+exports.isResponse = isResponse;
+exports.isStandardSchema = isStandardSchema;
+exports.isSuccessResponse = isSuccessResponse;
+exports.isUnknownErrorResponse = isUnknownErrorResponse;
+exports.isUnknownResponse = isUnknownResponse;
+exports.isUnknownSuccessResponse = isUnknownSuccessResponse;
+exports.mergeHeaderSchemasForRoute = mergeHeaderSchemasForRoute;
+exports.parseAsStandardSchema = parseAsStandardSchema;
+exports.parseJsonQueryObject = parseJsonQueryObject;
+exports.tsRestFetchApi = tsRestFetchApi;
+exports.validateAgainstStandardSchema = validateAgainstStandardSchema;
+exports.validateIfSchema = validateIfSchema;
+exports.validateMultiSchemaObject = validateMultiSchemaObject;
+exports.validateResponse = validateResponse;