@boxrouter/sdk 0.0.1-alpha.0 → 0.12.190

package/dist/core/responseContracts/volumes.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.operations = void 0;
+const loadValidators = () => import("../responseValidators/volumes.cjs").then(module => module.default);
+const loadDiagnostics = () => import("../responseValidators/volumes-diagnostics.cjs").then(module => module.default);
+exports.operations = { "GET /volumes": { responses: { "200": { "media": ["application/json"], "validator": "validate0" } }, completeErrors: { "400": false, "default": false }, loadValidators, loadDiagnostics },
+    "POST /volumes": { responses: { "201": { "media": ["application/json"], "validator": "validate1" } }, completeErrors: { "400": false, "409": false, "413": false, "default": false }, loadValidators, loadDiagnostics },
+    "GET /volumes/{volume_id}": { responses: { "200": { "media": ["application/json"], "validator": "validate2" } }, completeErrors: { "404": false, "default": false }, loadValidators, loadDiagnostics },
+    "DELETE /volumes/{volume_id}": { responses: { "204": { "media": [] } }, completeErrors: { "404": false, "409": false, "default": false } },
+    "GET /volumes/{volume_id}/checkpoints": { responses: { "200": { "media": ["application/json"], "validator": "validate3" } }, completeErrors: { "404": false, "default": false }, loadValidators, loadDiagnostics },
+    "POST /volumes/{volume_id}/checkpoints": { responses: { "201": { "media": ["application/json"], "validator": "validate4" } }, completeErrors: { "404": false, "409": false, "413": false, "502": false, "default": false }, loadValidators, loadDiagnostics },
+    "GET /volumes/{volume_id}/checkpoints/{checkpoint}": { responses: { "200": { "media": ["application/json"], "validator": "validate5" } }, completeErrors: { "404": false, "default": false }, loadValidators, loadDiagnostics },
+    "DELETE /volumes/{volume_id}/checkpoints/{checkpoint}": { responses: { "204": { "media": [] } }, completeErrors: { "404": false, "409": false, "default": false } },
+    "DELETE /volumes/{volume_id}/lease": { responses: { "204": { "media": [] } }, completeErrors: { "404": false, "409": false, "default": false } },
+    "POST /volumes/{volume_id}/uploads": { responses: { "201": { "media": ["application/json"], "validator": "validate6" } }, completeErrors: { "400": false, "404": false, "409": false, "413": false, "default": false }, loadValidators, loadDiagnostics },
+    "POST /volumes/{volume_id}/uploads/{upload_id}/complete": { responses: { "200": { "media": ["application/json"], "validator": "validate7" } }, completeErrors: { "400": false, "404": false, "409": false, "default": false }, loadValidators, loadDiagnostics },
+    "DELETE /volumes/{volume_id}/uploads/{upload_id}": { responses: { "204": { "media": [] } }, completeErrors: { "404": false, "default": false } },
+    "POST /volumes/{volume_id}/downloads": { responses: { "201": { "media": ["application/json"], "validator": "validate8" } }, completeErrors: { "400": false, "404": false, "default": false }, loadValidators, loadDiagnostics },
+    "GET /volumes/{volume_id}/files": { responses: { "200": { "media": ["application/json"], "validator": "validate9" } }, completeErrors: { "400": false, "404": false, "default": false }, loadValidators, loadDiagnostics } };

package/dist/core/responseContracts.gen.d.ts

@@ -0,0 +1,3 @@
+import type { ResponseOperation } from "./responseValidation";
+export declare const responseGroups: Record<string, string>;
+export declare const responseContractLoaders: Record<string, () => Promise<Record<string, ResponseOperation>>>;

package/dist/core/responseContracts.gen.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.responseContractLoaders = exports.responseGroups = void 0;
+exports.responseGroups = { "GET /agents": "agents", "GET /agents/{name}": "agents", "POST /launches": "launches", "GET /launches/{operation_id}": "launches", "GET /launches/{operation_id}/settings": "launches", "GET /launches/{operation_id}/command": "launches", "GET /launch-runs": "launchRuns", "POST /launch-runs": "launchRuns", "GET /launch-runs/{run_id}": "launchRuns", "POST /launch-runs/{run_id}/stop": "launchRuns", "POST /launch-runs/{run_id}/copies/{copy_index}/destroy": "launchRuns", "GET /repositories/{owner}/{repo}/access": "launches", "GET /github/installations": "github", "DELETE /github/installations/{installation_id}": "github", "GET /github/repositories": "github", "GET /actions/repositories/{repository_id}": "actions", "PUT /actions/repositories/{repository_id}": "actions", "GET /routing/settings": "routing", "PUT /routing/settings": "routing", "GET /routing/preview": "routing", "GET /actions/readiness": "actions", "GET /actions/runner-catalog": "actions", "GET /actions/policies": "actions", "POST /actions/policies": "actions", "GET /actions/policies/{policy_id}": "actions", "PUT /actions/policies/{policy_id}": "actions", "DELETE /actions/policies/{policy_id}": "actions", "POST /actions/preview": "actions", "GET /actions/runs": "actions", "GET /actions/runs/facets": "actions", "GET /actions/pool-idle-time": "actions", "GET /actions/runs/{run_id}": "actions", "GET /actions/runs/{run_id}/jobs": "actions", "GET /actions/runs/{run_id}/placements": "actions", "GET /actions/jobs/{job_id}": "actions", "GET /actions/jobs/{job_id}/steps": "actions", "GET /actions/jobs/{job_id}/logs": "actions", "GET /actions/jobs/{job_id}/steps/{step_position}/logs": "actions", "GET /actions/jobs/{job_id}/events": "actions", "GET /actions/placements/{placement_id}": "actions", "POST /actions/runs/{run_id}/cancel": "actions", "POST /actions/runs/{run_id}/rerun": "actions", "POST /actions/runs/{run_id}/rerun-failed-jobs": "actions", "GET /operations": "operations", "POST /artifacts": "artifacts", "GET /artifacts/{artifact_id}": "artifacts", "DELETE /artifacts/{artifact_id}": "artifacts", "POST /images/prepare": "images", "GET /images/preparations": "images", "POST /images/unprepare": "images", "POST /sandboxes/{sandbox_id}/processes": "processes", "GET /sandboxes/{sandbox_id}/processes/{process_id}": "processes", "DELETE /sandboxes/{sandbox_id}/processes/{process_id}": "processes", "POST /sandboxes/{sandbox_id}/processes/{process_id}/stdin": "processes", "POST /sandboxes/{sandbox_id}/processes/{process_id}/stdin/close": "processes", "POST /sandboxes/{sandbox_id}/processes/{process_id}/cancel": "processes", "GET /credits": "credits", "GET /spend-limits": "spend_limits", "PUT /spend-limits/{scope}": "spend_limits", "DELETE /spend-limits/{scope}": "spend_limits", "POST /credits/purchases": "credits", "GET /credits/purchases": "credits", "POST /credits/purchases/quote": "credits", "GET /credits/usage": "credits", "GET /usage": "usage", "GET /usage.csv": "usage", "GET /credits/purchases/{purchase_id}": "credits", "POST /credits/purchases/{purchase_id}/cancel": "credits", "POST /credits/promotions": "credits", "GET /credits/promotions": "credits", "GET /credits/billing-details": "credits", "PUT /credits/billing-details": "credits", "GET /credits/alerts": "credits", "PUT /credits/alerts": "credits", "GET /credits/payment-methods": "credits", "POST /credits/payment-methods/setup": "credits", "POST /credits/payment-methods/setup-intent": "credits", "PUT /credits/payment-methods/order": "credits", "GET /credits/payment-method-setups/{setup_id}": "credits", "DELETE /credits/payment-methods/{payment_method_id}": "credits", "POST /credits/payment-methods/{payment_method_id}/default": "credits", "GET /credits/auto-top-up": "credits", "PUT /credits/auto-top-up": "credits", "POST /sandboxes/{sandbox_id}/terminals": "terminals", "GET /sandboxes/{sandbox_id}/terminals/{terminal_id}": "terminals", "GET /sandboxes/{sandbox_id}/terminals/{terminal_id}/events": "terminals", "POST /sandboxes/{sandbox_id}/terminals/{terminal_id}/input": "terminals", "POST /sandboxes/{sandbox_id}/terminals/{terminal_id}/resize": "terminals", "POST /sandboxes/{sandbox_id}/terminals/{terminal_id}/kill": "terminals", "GET /secrets": "secrets", "PUT /secrets/{name}": "secrets", "DELETE /secrets/{name}": "secrets", "GET /sandboxes/{sandbox_id}/previews": "previews", "POST /sandboxes/{sandbox_id}/previews": "previews", "DELETE /sandboxes/{sandbox_id}/previews/{preview_id}": "previews", "POST /sandboxes/{sandbox_id}/browser": "sandboxes", "POST /sandboxes/{sandbox_id}/pause": "sandboxes", "POST /sandboxes/{sandbox_id}/resume": "sandboxes", "POST /sandboxes/{sandbox_id}/lifetime": "sandboxes", "POST /sandboxes/{sandbox_id}/network-policy": "sandboxes", "POST /provider-accounts": "provider_accounts", "GET /provider-accounts": "provider_accounts", "POST /provider-accounts/test": "provider_accounts", "GET /provider-accounts/{account_id}": "provider_accounts", "DELETE /provider-accounts/{account_id}": "provider_accounts", "PUT /provider-accounts/{account_id}/credentials": "provider_accounts", "POST /provider-accounts/{account_id}/test": "provider_accounts", "POST /provider-accounts/{account_id}/standard-image/setup": "provider_accounts", "GET /operations/{operation_id}": "operations", "GET /volumes": "volumes", "POST /volumes": "volumes", "GET /volumes/{volume_id}": "volumes", "DELETE /volumes/{volume_id}": "volumes", "GET /volumes/{volume_id}/checkpoints": "volumes", "POST /volumes/{volume_id}/checkpoints": "volumes", "GET /volumes/{volume_id}/checkpoints/{checkpoint}": "volumes", "DELETE /volumes/{volume_id}/checkpoints/{checkpoint}": "volumes", "DELETE /volumes/{volume_id}/lease": "volumes", "POST /volumes/{volume_id}/uploads": "volumes", "POST /volumes/{volume_id}/uploads/{upload_id}/complete": "volumes", "DELETE /volumes/{volume_id}/uploads/{upload_id}": "volumes", "POST /volumes/{volume_id}/downloads": "volumes", "GET /volumes/{volume_id}/files": "volumes", "POST /sandboxes": "sandboxes", "GET /sandboxes": "sandboxes", "POST /sandboxes/match": "sandboxes", "GET /sandboxes/{sandbox_id}": "sandboxes", "DELETE /sandboxes/{sandbox_id}": "sandboxes", "POST /sandboxes/{sandbox_id}/commands": "commands", "GET /sandboxes/{sandbox_id}/files/content": "files", "PUT /sandboxes/{sandbox_id}/files/content": "files", "POST /sandboxes/{sandbox_id}/files/uploads": "files", "POST /sandboxes/{sandbox_id}/files/uploads/{upload_id}/complete": "files", "DELETE /sandboxes/{sandbox_id}/files/uploads/{upload_id}": "files", "POST /sandboxes/{sandbox_id}/files/downloads": "files", "GET /sandboxes/{sandbox_id}/files/directories": "files", "POST /sandboxes/{sandbox_id}/files/directories": "files", "GET /sandboxes/{sandbox_id}/files/exists": "files", "POST /sandboxes/{sandbox_id}/files/remove": "files", "GET /price-versions": "pricing", "GET /providers": "providers" };
+exports.responseContractLoaders = { "agents": () => import("./responseContracts/agents.js").then(module => module.operations),
+    "launches": () => import("./responseContracts/launches.js").then(module => module.operations),
+    "launchRuns": () => import("./responseContracts/launchRuns.js").then(module => module.operations),
+    "github": () => import("./responseContracts/github.js").then(module => module.operations),
+    "actions": () => import("./responseContracts/actions.js").then(module => module.operations),
+    "routing": () => import("./responseContracts/routing.js").then(module => module.operations),
+    "operations": () => import("./responseContracts/operations.js").then(module => module.operations),
+    "artifacts": () => import("./responseContracts/artifacts.js").then(module => module.operations),
+    "images": () => import("./responseContracts/images.js").then(module => module.operations),
+    "processes": () => import("./responseContracts/processes.js").then(module => module.operations),
+    "credits": () => import("./responseContracts/credits.js").then(module => module.operations),
+    "spend_limits": () => import("./responseContracts/spend_limits.js").then(module => module.operations),
+    "usage": () => import("./responseContracts/usage.js").then(module => module.operations),
+    "terminals": () => import("./responseContracts/terminals.js").then(module => module.operations),
+    "secrets": () => import("./responseContracts/secrets.js").then(module => module.operations),
+    "previews": () => import("./responseContracts/previews.js").then(module => module.operations),
+    "sandboxes": () => import("./responseContracts/sandboxes.js").then(module => module.operations),
+    "provider_accounts": () => import("./responseContracts/provider_accounts.js").then(module => module.operations),
+    "volumes": () => import("./responseContracts/volumes.js").then(module => module.operations),
+    "commands": () => import("./responseContracts/commands.js").then(module => module.operations),
+    "files": () => import("./responseContracts/files.js").then(module => module.operations),
+    "pricing": () => import("./responseContracts/pricing.js").then(module => module.operations),
+    "providers": () => import("./responseContracts/providers.js").then(module => module.operations) };

package/dist/core/responseModes.d.ts

@@ -0,0 +1,19 @@
+type ResponseBodyMode<Body, Mode extends boolean> = Body extends unknown ? Omit<Body, 'stream'> & {
+    stream?: Mode;
+} : never;
+export type ResponseModeOptions<T extends {
+    body: {
+        stream?: boolean;
+    };
+}, Mode extends boolean> = Omit<T, 'body'> & {
+    body: ResponseBodyMode<T['body'], Mode>;
+};
+/** A named response variant must select the matching server-side behavior. */
+export declare function withResponseMode<T extends {
+    body: {
+        stream?: boolean;
+    };
+    headers?: Config['headers'];
+}>(options: T, stream: boolean): T;
+import type { Config } from './types.gen';
+export {};

package/dist/core/responseModes.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withResponseMode = withResponseMode;
+/** A named response variant must select the matching server-side behavior. */
+function withResponseMode(options, stream) {
+    if (options.body.stream !== undefined && options.body.stream !== stream) {
+        throw new TypeError(`This method requires stream=${stream}`);
+    }
+    const headers = (0, client_1.mergeHeaders)(options.headers);
+    headers.set('Accept', stream ? 'text/event-stream' : 'application/json');
+    return { ...options, body: { ...options.body, stream }, headers: Object.fromEntries(headers) };
+}
+const client_1 = require("../client");

package/dist/core/responseValidation.d.ts

@@ -0,0 +1,44 @@
+import { type ResponseSchemaDiagnostic } from '../api-error';
+import type { RequestTrace } from '../telemetry';
+type Contracts = Record<string, ResponseOperation>;
+type ContractIndex = {
+    groups: Record<string, string>;
+    loaders: Record<string, () => Promise<Contracts>>;
+};
+type ValidatorIssue = Pick<ResponseSchemaDiagnostic, 'keyword' | 'instancePath' | 'schemaPath'>;
+type Validator = ((value: unknown) => boolean) & {
+    errors?: readonly ValidatorIssue[] | null;
+};
+type Validators = Record<string, Validator>;
+export type ResponseContract = Record<string, {
+    media: string[];
+    validator?: string;
+}>;
+export type ResponseOperation = {
+    responses: ResponseContract;
+    completeErrors: Record<string, boolean>;
+    loadValidators?: () => Promise<Validators>;
+    loadDiagnostics?: () => Promise<Validators>;
+};
+type Prepared = {
+    contract?: ResponseContract;
+    completeErrors?: Record<string, boolean>;
+    validators?: Validators;
+    loadDiagnostics?: () => Promise<Validators>;
+};
+type ParseAs = 'arrayBuffer' | 'auto' | 'binaryStream' | 'blob' | 'formData' | 'json' | 'stream' | 'text';
+/** Missing contract or validator chunks fail before an operation can dispatch. */
+export declare function prepareResponseValidation(method: string | undefined, path: string, signal?: AbortSignal | null, index?: ContractIndex): Promise<Prepared>;
+/**
+ * Canonical media selects validation; caller parsing options cannot disable it. Only a caller
+ * that parses JSON can omit the trace; every other parse mode may stream and must provide one.
+ */
+export declare function parseValidatedResponse(response: Response, request: Request, prepared: Prepared, parseAs: 'json', telemetry?: RequestTrace): Promise<{
+    data: unknown;
+    isJson: boolean;
+}>;
+export declare function parseValidatedResponse(response: Response, request: Request, prepared: Prepared, parseAs: ParseAs, telemetry: RequestTrace): Promise<{
+    data: unknown;
+    isJson: boolean;
+}>;
+export {};

package/dist/core/responseValidation.js

@@ -0,0 +1,174 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prepareResponseValidation = prepareResponseValidation;
+exports.parseValidatedResponse = parseValidatedResponse;
+const workflow_policy_gen_1 = require("../workflow-policy.gen");
+const api_1 = require("@opentelemetry/api");
+const api_error_1 = require("../api-error");
+const json_1 = require("./json");
+const responseContracts_gen_1 = require("./responseContracts.gen");
+const mainIndex = { groups: responseContracts_gen_1.responseGroups, loaders: responseContracts_gen_1.responseContractLoaders };
+// Each index caches its own namespaces, so two indexes can share a group name.
+const caches = new WeakMap();
+/** Settle with the caller's cancellation without cancelling the shared load. */
+async function untilAborted(pending, signal) {
+    if (!signal)
+        return pending;
+    let abort;
+    try {
+        return await Promise.race([pending, new Promise((_, reject) => {
+                signal.addEventListener('abort', abort = () => reject(signal.reason));
+            })]);
+    }
+    finally {
+        signal.removeEventListener('abort', abort);
+    }
+}
+/** Missing contract or validator chunks fail before an operation can dispatch. */
+async function prepareResponseValidation(method, path, signal, index = mainIndex) {
+    signal?.throwIfAborted();
+    const key = `${method} ${path}`;
+    const group = index.groups[key];
+    const loadContracts = group && index.loaders[group];
+    const contracts = caches.get(index) ?? new Map();
+    caches.set(index, contracts);
+    let operation;
+    const parent = api_1.context.active();
+    if (loadContracts) {
+        // A namespace's contracts load once and callers share the load; later calls add no asynchronous hop.
+        let loaded = contracts.get(group);
+        if (!loaded) {
+            contracts.set(group, loaded = loadContracts().then(table => { contracts.set(group, table); return table; }, error => { contracts.delete(group); throw error; }));
+        }
+        operation = (loaded.then ? await untilAborted(loaded, signal) : loaded)[key];
+    }
+    const validators = operation?.loadValidators && await untilAborted(operation.loadValidators(), signal);
+    return api_1.context.with(parent, () => ({ contract: operation?.responses, completeErrors: operation?.completeErrors,
+        validators, loadDiagnostics: operation?.loadDiagnostics }));
+}
+/** Retain declared complete errors or bounded diagnostics, plus mutation identity on disconnect. */
+async function responseError(response, request, invalid, complete) {
+    const reader = response.body?.getReader();
+    const chunks = [];
+    const limit = complete ? Infinity : workflow_policy_gen_1.MAX_ERROR_BYTES;
+    let length = 0;
+    const abort = () => { void reader?.cancel(request.signal.reason).catch(() => { }); };
+    request.signal.addEventListener('abort', abort, { once: true });
+    try {
+        if (request.signal.aborted)
+            abort();
+        if (reader) {
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                const chunk = complete ? value : value.slice(0, limit - length);
+                chunks.push(chunk);
+                length += chunk.byteLength;
+                if (length === limit)
+                    break;
+            }
+        }
+    }
+    catch {
+        // The received HTTP status and request still provide recovery context.
+    }
+    finally {
+        request.signal.removeEventListener('abort', abort);
+        if (reader) {
+            await reader.cancel().catch(() => { });
+            reader.releaseLock();
+        }
+    }
+    const buffer = new Uint8Array(length);
+    let offset = 0;
+    for (const chunk of chunks) {
+        buffer.set(chunk, offset);
+        offset += chunk.byteLength;
+    }
+    let payload;
+    try {
+        payload = (0, json_1.parseJson)(new TextDecoder().decode(buffer.subarray(0, length)));
+    }
+    catch { /* No JSON envelope. */ }
+    if (invalid)
+        return (0, api_error_1.invalidResponse)(response, request, payload);
+    return new api_error_1.APIError(payload, response, request);
+}
+/** Binary streaming reports through the request's trace; a caller without one cannot stream. */
+function streamTrace(telemetry) {
+    if (!telemetry)
+        throw new TypeError('Streaming a response requires a request trace');
+    return telemetry;
+}
+async function parseValidatedResponse(response, request, prepared, parseAs, telemetry) {
+    const declaration = prepared.contract?.[String(response.status)];
+    const media = response.headers.get('content-type')?.split(';', 1)[0].trim().toLowerCase() ?? '';
+    if (!response.ok || (prepared.contract && !declaration) ||
+        (declaration?.media.length && !declaration.media.includes(media))) {
+        const status = String(response.status);
+        const complete = !response.ok && media === 'application/json' &&
+            (prepared.completeErrors?.[status] ?? prepared.completeErrors?.default) === true;
+        throw await responseError(response, request, response.ok, complete);
+    }
+    if (response.status === 204 || declaration?.media.length === 0)
+        return { data: undefined, isJson: false };
+    const json = media === 'application/json' && declaration?.validator !== undefined;
+    const mode = parseAs === 'auto' || parseAs === 'binaryStream' || parseAs === undefined
+        ? (media === 'application/json' ? 'json' : parseAs === 'binaryStream' ? 'stream'
+            : media.startsWith('text/') ? 'text' : 'blob') : parseAs;
+    // A missing trace is a caller error, not an invalid response, so it must not reach the catch below.
+    const trace = mode === 'stream' ? streamTrace(telemetry) : undefined;
+    if (json || mode === 'json') {
+        let text;
+        let data;
+        let unknownKind = false;
+        let schemaDiagnostics;
+        try {
+            text = await response.text();
+            data = (0, json_1.parseJson)(text);
+            if (json) {
+                const validate = prepared.validators[declaration.validator];
+                if (!validate(data)) {
+                    const detailed = prepared.loadDiagnostics
+                        ? (await prepared.loadDiagnostics())[declaration.validator] : validate;
+                    if (detailed !== validate)
+                        detailed(data);
+                    // An enum/constant failure identifies a closed vocabulary mismatch, not an unknown
+                    // record kind. In particular, a legacy/current response union can fail because a
+                    // nested closed field has a future value.
+                    const errors = detailed.errors ?? [];
+                    schemaDiagnostics = errors;
+                    const failedRecordUnion = errors.some(({ keyword, instancePath }) => (keyword === 'anyOf' || keyword === 'oneOf') && isRecord(pointerValue(data, instancePath)) &&
+                        !errors.some(error => (error.keyword === 'anyOf' || error.keyword === 'oneOf') &&
+                            error.instancePath !== instancePath && !isRecord(pointerValue(data, error.instancePath))));
+                    const hasClosedValueFailure = errors.some(({ keyword }) => keyword === 'enum' || keyword === 'const');
+                    unknownKind = failedRecordUnion && !hasClosedValueFailure;
+                    throw new TypeError('Invalid schema');
+                }
+            }
+        }
+        catch {
+            throw (0, api_error_1.invalidResponse)(response, request, data, unknownKind, schemaDiagnostics);
+        }
+        if (mode === 'json')
+            return { data, isJson: true };
+        const buffered = new Response(text, { headers: response.headers });
+        return { data: mode === 'stream' ? (await import('./binaryStream.js')).binaryStream(buffered.body, response, request, trace)
+                : await buffered[mode](), isJson: false };
+    }
+    try {
+        return { data: mode === 'stream' ? (await import('./binaryStream.js')).binaryStream(response.body, response, request, trace)
+                : await response[mode](), isJson: false };
+    }
+    catch {
+        throw (0, api_error_1.invalidResponse)(response, request);
+    }
+}
+function pointerValue(value, pointer) {
+    return pointer.split('/').slice(1).reduce((node, key) => node !== null && typeof node === 'object'
+        ? node[key.replaceAll('~1', '/').replaceAll('~0', '~')] : undefined, value);
+}
+function isRecord(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}