@metabase/cli 0.3.1-alpha.transform-tests.c0bc2d1 → 0.3.1-alpha.transform-tests.d9ed765

package/dist/network-error-D6CiOEBw.mjs

@@ -1,431 +0,0 @@
-import { d as ValidationError, f as errorMessage, i as ConfigError, o as MetabaseError, r as ChainedRequestError, s as NetworkError, t as isPlainObject } from "./predicates-Bkm2IoeX.mjs";
-import { z } from "zod";
-//#region ../client/src/json.ts
-const JSON_CONTENT_TYPE = "application/json";
-function parseJson(input, schema, opts = {}) {
-	const result = parseJsonResult(input, schema, opts);
-	if (!result.ok) throw result.error;
-	return result.value;
-}
-function parseJsonResult(input, schema, opts = {}) {
-	const sourcePrefix = opts.source === void 0 ? "" : `${opts.source}: `;
-	let raw;
-	try {
-		raw = JSON.parse(input);
-	} catch (error) {
-		return {
-			ok: false,
-			error: new ConfigError(`${sourcePrefix}invalid JSON: ${errorMessage(error)}`)
-		};
-	}
-	const parsed = schema.safeParse(raw);
-	if (!parsed.success) return {
-		ok: false,
-		error: new ValidationError(`${sourcePrefix}value did not match expected schema`, {
-			source: opts.source ?? "<input>",
-			zodIssues: parsed.error.issues
-		})
-	};
-	return {
-		ok: true,
-		value: parsed.data
-	};
-}
-function parseJsonOrPlain(text, contentType, schema, opts = {}) {
-	if (!isJsonContentType(contentType)) return parseJson(JSON.stringify(text), schema, opts);
-	const attempt = parseJsonResult(text, schema, opts);
-	if (attempt.ok) return attempt.value;
-	if (attempt.error instanceof ValidationError) throw attempt.error;
-	return parseJson(JSON.stringify(text), schema, opts);
-}
-function isJsonContentType(contentType) {
-	return contentType !== null && contentType.includes("application/json");
-}
-//#endregion
-//#region ../client/src/auth/credential.ts
-const API_KEY_HEADER = "x-api-key";
-const AUTHORIZATION_HEADER = "authorization";
-const BEARER_PREFIX = "Bearer ";
-const EXPIRY_SKEW_MS = 6e4;
-function credentialAuthHeader(credential) {
-	if (credential.kind === "apiKey") return {
-		name: API_KEY_HEADER,
-		value: credential.apiKey
-	};
-	return {
-		name: AUTHORIZATION_HEADER,
-		value: BEARER_PREFIX + credential.accessToken
-	};
-}
-const MAX_HEADER_CODE_UNIT = 255;
-function headerBearingSecret(credential) {
-	if (credential.kind === "apiKey") return {
-		field: "apiKey",
-		value: credential.apiKey
-	};
-	return {
-		field: "accessToken",
-		value: credential.accessToken
-	};
-}
-function assertCredentialHeaderSafe(credential) {
-	const { field, value } = headerBearingSecret(credential);
-	for (let index = 0; index < value.length; index += 1) {
-		const codeUnit = value.charCodeAt(index);
-		if (codeUnit > MAX_HEADER_CODE_UNIT) {
-			const codePoint = codeUnit.toString(16).toUpperCase().padStart(4, "0");
-			throw new ConfigError(`Credential field "${field}" has a character at index ${index} (U+${codePoint}) that cannot be sent in an HTTP header. Header values are limited to Latin-1; a smart quote, ellipsis, or dash substituted during copy-paste is the usual cause.`);
-		}
-	}
-}
-function credentialSecrets(credential) {
-	if (credential.kind === "apiKey") return [credential.apiKey];
-	return [credential.accessToken, credential.refreshToken];
-}
-function isOAuthExpired(credential, nowMs) {
-	const expiryMs = Date.parse(credential.expiresAt);
-	if (Number.isNaN(expiryMs)) return true;
-	return expiryMs - EXPIRY_SKEW_MS <= nowMs;
-}
-function expiresAtFromNow(expiresInSeconds, nowMs) {
-	return new Date(nowMs + expiresInSeconds * 1e3).toISOString();
-}
-function oauthCredentialFromTokens(tokens, refreshToken, clientId, nowMs) {
-	return {
-		kind: "oauth",
-		accessToken: tokens.access_token,
-		refreshToken,
-		expiresAt: expiresAtFromNow(tokens.expires_in ?? 3600, nowMs),
-		clientId
-	};
-}
-//#endregion
-//#region ../client/src/url.ts
-function normalizeUrl(input) {
-	const trimmed = input.trim().replace(/\/+$/, "");
-	if (!/^https?:\/\//i.test(trimmed)) throw new ConfigError("URL must start with http:// or https://");
-	return trimmed;
-}
-function displayUrl(input) {
-	const parsed = new URL(input);
-	const path = parsed.pathname.replace(/\/+$/, "");
-	return `${parsed.origin}${path}`;
-}
-const LOOPBACK_HOSTS = /* @__PURE__ */ new Set([
-	"localhost",
-	"127.0.0.1",
-	"::1",
-	"[::1]"
-]);
-function isLoopbackHost(hostname) {
-	return LOOPBACK_HOSTS.has(hostname.toLowerCase());
-}
-function assertEndpointOrigin(endpoint, baseUrl, label) {
-	let parsed;
-	try {
-		parsed = new URL(endpoint);
-	} catch {
-		throw new ConfigError(`OAuth ${label} is not a valid URL: ${endpoint}`);
-	}
-	const base = new URL(baseUrl);
-	if (parsed.protocol !== "https:" && !isLoopbackHost(parsed.hostname)) throw new ConfigError(`OAuth ${label} must use https: ${endpoint}`);
-	if (parsed.origin !== base.origin) throw new ConfigError(`OAuth ${label} origin (${parsed.origin}) does not match the Metabase URL (${base.origin})`);
-}
-//#endregion
-//#region ../client/src/http/sanitize.ts
-const SECRET_HEADER_NAMES = /* @__PURE__ */ new Set([
-	"authorization",
-	"x-api-key",
-	"x-metabase-session",
-	"cookie",
-	"set-cookie",
-	"proxy-authorization"
-]);
-const REDACTED = "[REDACTED]";
-function redactHeaders(headers) {
-	const result = {};
-	const entries = headers instanceof Headers ? headers.entries() : Object.entries(headers);
-	for (const [key, value] of entries) result[key] = SECRET_HEADER_NAMES.has(key.toLowerCase()) ? REDACTED : value;
-	return result;
-}
-function redactBody(body, ctx) {
-	let result = body;
-	for (const secret of ctx.knownSecrets) {
-		if (secret.length === 0) continue;
-		result = result.replaceAll(secret, REDACTED);
-	}
-	return result;
-}
-//#endregion
-//#region ../client/src/http/errors.ts
-const NOT_FOUND_STATUS = 404;
-const TEXT_CONTENT_TYPE = "text/plain";
-const ROUTE_MISSING_LITERAL = "API endpoint does not exist.";
-const RESOURCE_MISSING_LITERAL = "Not found.";
-const STATUS_CLASSIFICATIONS = {
-	401: { retryable: false },
-	403: { retryable: false },
-	404: { retryable: false },
-	408: {
-		retryable: true,
-		message: "Metabase timed out responding."
-	},
-	425: { retryable: true },
-	429: {
-		retryable: true,
-		message: "Metabase rate-limited the request."
-	},
-	500: { retryable: true },
-	502: { retryable: true },
-	503: { retryable: true },
-	504: {
-		retryable: true,
-		message: "Metabase timed out responding."
-	}
-};
-const ErrorEnvelope = z.object({
-	message: z.string().optional(),
-	error: z.string().optional(),
-	"error-message": z.string().optional(),
-	via: z.array(z.object({ message: z.string().optional() }).loose()).optional(),
-	"specific-errors": z.unknown().optional(),
-	errors: z.unknown().optional()
-}).loose();
-const FieldErrorNodeSchema = z.lazy(() => z.union([
-	z.string(),
-	z.array(z.string()),
-	z.record(z.string(), FieldErrorNodeSchema)
-]));
-const FieldErrorTree = z.record(z.string(), FieldErrorNodeSchema);
-const FIELD_MESSAGE_SEPARATOR = "; ";
-const MAX_EXTRACTED_MESSAGE_LEN = 500;
-const ELLIPSIS = "…";
-var HttpError = class extends MetabaseError {
-	category = "http";
-	status;
-	kind;
-	developerDetail;
-	constructor(input) {
-		const sanitizedBody = sanitizeBody(input.rawBody, input.redactionContext);
-		const redactedHeaders = redactHeaders(input.responseHeaders);
-		const kind = classifyKind(input.status, sanitizedBody, redactedHeaders);
-		super(input.overrideUserMessage ?? buildUserMessage(kind, input, sanitizedBody, redactedHeaders));
-		const fields = extractFieldErrors(sanitizedBody);
-		this.name = "HttpError";
-		this.status = input.status;
-		this.kind = kind;
-		this.developerDetail = {
-			status: input.status,
-			statusText: input.statusText,
-			method: input.method,
-			url: input.url,
-			responseHeaders: redactedHeaders,
-			body: sanitizedBody,
-			fieldErrors: fields.fieldErrors,
-			specificFieldErrors: fields.specificFieldErrors
-		};
-	}
-	get isRetryable() {
-		return isRetryableStatus(this.status);
-	}
-	get fieldErrors() {
-		return this.developerDetail.fieldErrors;
-	}
-	get specificFieldErrors() {
-		return this.developerDetail.specificFieldErrors;
-	}
-};
-function chainRequestFailure(cause, message) {
-	if (cause instanceof HttpError) return new HttpError({
-		status: cause.status,
-		statusText: cause.developerDetail.statusText,
-		method: cause.developerDetail.method,
-		url: cause.developerDetail.url,
-		responseHeaders: cause.developerDetail.responseHeaders,
-		rawBody: cause.developerDetail.body,
-		overrideUserMessage: message
-	});
-	return new ChainedRequestError(message, cause);
-}
-function isRetryableStatus(status) {
-	return STATUS_CLASSIFICATIONS[status]?.retryable === true;
-}
-function sanitizeBody(rawBody, ctx) {
-	if (rawBody === null) return null;
-	if (ctx === void 0) return rawBody;
-	return redactBody(rawBody, ctx);
-}
-function classifyKind(status, sanitizedBody, redactedHeaders) {
-	if (status === 401 || status === 403) return "auth";
-	if (status === NOT_FOUND_STATUS) return isRouteMissingResponse(sanitizedBody, redactedHeaders) ? "route-missing" : "resource-missing";
-	if (status === 429) return "rate-limit";
-	if (status >= 500 && status < 600) return "server-error";
-	return "generic";
-}
-function isRouteMissingResponse(sanitizedBody, redactedHeaders) {
-	if (sanitizedBody?.includes(ROUTE_MISSING_LITERAL)) return true;
-	if (sanitizedBody?.includes(RESOURCE_MISSING_LITERAL)) return false;
-	if (redactedHeaders["content-type"]?.includes("application/json")) return false;
-	if (sanitizedBody === null || sanitizedBody.trim() === "") return true;
-	return parseEnvelope(sanitizedBody) === null;
-}
-function buildUserMessage(kind, input, sanitizedBody, redactedHeaders) {
-	if (kind === "route-missing") return buildRouteMissingMessage(input);
-	if (kind === "resource-missing") return `Not found: ${input.method} ${pathFromUrl(input.url)}.`;
-	const fromBody = parseEnvelopeMessage(sanitizedBody);
-	if (fromBody !== null) return fromBody;
-	if (kind === "auth") return `Invalid or unauthorized API key (host: ${hostFromUrl(input.url)}).`;
-	const fromText = plainTextMessage(sanitizedBody, redactedHeaders);
-	if (fromText !== null) return fromText;
-	return defaultMessageForStatus(input.status);
-}
-function plainTextMessage(sanitizedBody, redactedHeaders) {
-	if (sanitizedBody === null || !redactedHeaders["content-type"]?.includes(TEXT_CONTENT_TYPE)) return null;
-	const trimmed = sanitizedBody.trim();
-	return trimmed === "" ? null : capLength(trimmed);
-}
-function buildRouteMissingMessage(input) {
-	const path = pathFromUrl(input.url);
-	if (!input.serverTag) return `This endpoint is not available on the connected Metabase: ${input.method} ${path}.`;
-	return `This endpoint is not available on Metabase ${input.serverTag}: ${input.method} ${path}. It may require a newer Metabase major version.`;
-}
-function pathFromUrl(url) {
-	const parsed = new URL(url);
-	return parsed.pathname + parsed.search;
-}
-function hostFromUrl(url) {
-	return new URL(url).host;
-}
-function parseEnvelope(sanitizedBody) {
-	if (!sanitizedBody) return null;
-	const result = parseJsonResult(sanitizedBody, ErrorEnvelope);
-	return result.ok ? result.value : null;
-}
-const NO_FIELD_ERRORS = {
-	fieldErrors: null,
-	specificFieldErrors: null
-};
-function extractFieldErrors(sanitizedBody) {
-	const envelope = parseEnvelope(sanitizedBody);
-	if (envelope === null) return NO_FIELD_ERRORS;
-	return {
-		fieldErrors: parseFieldErrors(envelope.errors),
-		specificFieldErrors: parseFieldErrors(envelope["specific-errors"])
-	};
-}
-function parseFieldErrors(value) {
-	const parsed = FieldErrorTree.safeParse(value);
-	if (!parsed.success) return null;
-	const entries = collectLeafEntries(parsed.data, []);
-	if (entries.length === 0) return null;
-	return Object.fromEntries(entries.map((entry) => [entry.path, entry.message]));
-}
-function parseEnvelopeMessage(sanitizedBody) {
-	const envelope = parseEnvelope(sanitizedBody);
-	if (envelope === null) return null;
-	const topLevel = envelope.message ?? envelope.error ?? envelope["error-message"];
-	if (topLevel) return capLength(topLevel);
-	const viaMessage = envelope.via?.find((entry) => entry.message)?.message;
-	if (viaMessage) return capLength(viaMessage);
-	const specific = formatErrorTree(envelope["specific-errors"]);
-	if (specific) return capLength(specific);
-	const generic = formatErrorTree(envelope.errors);
-	if (generic) return capLength(generic);
-	return null;
-}
-function formatErrorTree(value) {
-	const entries = collectLeafEntries(value, []);
-	if (entries.length === 0) return null;
-	return entries.map(formatLeafEntry).join(FIELD_MESSAGE_SEPARATOR);
-}
-function formatLeafEntry(entry) {
-	return entry.path === "" ? entry.message : `${entry.path}: ${entry.message}`;
-}
-function collectLeafEntries(value, path) {
-	if (typeof value === "string") {
-		const trimmed = value.trim();
-		return trimmed === "" ? [] : [{
-			path: path.join("."),
-			message: trimmed
-		}];
-	}
-	if (Array.isArray(value)) {
-		const messages = value.filter((entry) => typeof entry === "string" && entry.trim() !== "");
-		if (messages.length === 0) return [];
-		return [{
-			path: path.join("."),
-			message: messages.join(FIELD_MESSAGE_SEPARATOR)
-		}];
-	}
-	if (isPlainObject(value)) return Object.entries(value).flatMap(([key, child]) => collectLeafEntries(child, [...path, key]));
-	return [];
-}
-function capLength(message) {
-	if (message.length <= MAX_EXTRACTED_MESSAGE_LEN) return message;
-	return message.slice(0, MAX_EXTRACTED_MESSAGE_LEN - 1) + ELLIPSIS;
-}
-function defaultMessageForStatus(status) {
-	return STATUS_CLASSIFICATIONS[status]?.message ?? `Metabase returned ${status}.`;
-}
-//#endregion
-//#region ../client/src/http/network-error.ts
-const NETWORK_HINTS = {
-	ECONNREFUSED: (t) => `Connection refused by ${t.host} — is Metabase running and is the port correct?`,
-	ENOTFOUND: (t) => `Host not found: ${t.hostname} — check the URL.`,
-	EAI_AGAIN: (t) => `Could not resolve ${t.hostname} — check your network connection and the URL.`,
-	ECONNRESET: (t) => `Connection to ${t.host} was reset — the server may have closed it, or http/https may be mismatched.`,
-	UND_ERR_SOCKET: (t) => `Connection to ${t.host} was closed by the other side — a pooled connection or a proxy may have dropped it.`,
-	EPIPE: (t) => `Connection to ${t.host} closed while the request was still being written — the server or a proxy dropped it.`,
-	ETIMEDOUT: (t) => `Connection to ${t.host} timed out — check the host, port, and your network.`
-};
-const CONNECTION_CLOSED_CODES = /* @__PURE__ */ new Set([
-	"ECONNRESET",
-	"UND_ERR_SOCKET",
-	"EPIPE"
-]);
-const TLS_ERROR_CODES = /* @__PURE__ */ new Set([
-	"EPROTO",
-	"DEPTH_ZERO_SELF_SIGNED_CERT",
-	"SELF_SIGNED_CERT_IN_CHAIN",
-	"UNABLE_TO_VERIFY_LEAF_SIGNATURE",
-	"CERT_HAS_EXPIRED",
-	"ERR_TLS_CERT_ALTNAME_INVALID"
-]);
-function buildNetworkError(error, method, url) {
-	const fallback = errorMessage(error);
-	const code = failureCode(error);
-	return new NetworkError(networkMessage(code, networkTarget(url), fallback), {
-		method,
-		url,
-		cause: code ?? fallback
-	});
-}
-function isConnectionClosed(error) {
-	const code = failureCode(error);
-	return code !== null && CONNECTION_CLOSED_CODES.has(code);
-}
-function networkMessage(code, target, fallback) {
-	if (code === null) return `Could not reach Metabase: ${fallback}`;
-	if (TLS_ERROR_CODES.has(code)) return `Could not reach Metabase: TLS error contacting ${target.host} (${code}) — the certificate could not be verified, or https:// was used against a plain-HTTP server. For a certificate the OS does not trust either, set NODE_EXTRA_CA_CERTS to its CA bundle.`;
-	const hint = NETWORK_HINTS[code];
-	if (hint === void 0) return `Could not reach Metabase: ${fallback} (${code})`;
-	return `Could not reach Metabase: ${hint(target)}`;
-}
-function failureCode(error) {
-	const own = errorCode(error);
-	if (own !== null) return own;
-	return errorCode(error instanceof Error ? error.cause : void 0);
-}
-function errorCode(value) {
-	if (value instanceof Error && "code" in value && typeof value.code === "string") return value.code;
-	return null;
-}
-function networkTarget(url) {
-	const parsed = new URL(url);
-	return {
-		host: parsed.host,
-		hostname: parsed.hostname
-	};
-}
-//#endregion
-export { parseJsonResult as _, isRetryableStatus as a, normalizeUrl as c, credentialSecrets as d, isOAuthExpired as f, parseJsonOrPlain as g, parseJson as h, chainRequestFailure as i, assertCredentialHeaderSafe as l, JSON_CONTENT_TYPE as m, isConnectionClosed as n, assertEndpointOrigin as o, oauthCredentialFromTokens as p, HttpError as r, displayUrl as s, buildNetworkError as t, credentialAuthHeader as u };

package/dist/predicates-Bkm2IoeX.mjs

@@ -1,170 +0,0 @@
-import { ZodError, core } from "zod";
-//#region ../client/src/json-pointer.ts
-function escapeJsonPointerSegment(key) {
-	if (typeof key === "number") return String(key);
-	return (typeof key === "symbol" ? key.toString() : key).replaceAll("~", "~0").replaceAll("/", "~1");
-}
-//#endregion
-//#region ../client/src/errors.ts
-var MetabaseError = class extends Error {
-	get userMessage() {
-		return this.message;
-	}
-};
-var NetworkError = class extends MetabaseError {
-	category = "network";
-	isRetryable = true;
-	developerDetail;
-	constructor(message, developerDetail) {
-		super(message);
-		this.name = "NetworkError";
-		this.developerDetail = developerDetail;
-	}
-};
-var TimeoutError = class extends MetabaseError {
-	category = "timeout";
-	isRetryable = true;
-	developerDetail;
-	constructor(message, developerDetail) {
-		super(message);
-		this.name = "TimeoutError";
-		this.developerDetail = developerDetail;
-	}
-};
-var ValidationError = class extends MetabaseError {
-	category = "validation";
-	isRetryable = false;
-	developerDetail;
-	constructor(message, developerDetail) {
-		super(message);
-		this.name = "ValidationError";
-		this.developerDetail = developerDetail;
-	}
-	get userMessage() {
-		const issues = this.developerDetail.zodIssues;
-		if (issues.length === 0) return this.message;
-		return `${this.message}\n${formatIssueLines(issues, VALIDATION_ISSUE_FORMAT)}`;
-	}
-};
-const VALIDATION_MAX_ISSUES = 10;
-const RESPONSE_SHAPE_MAX_ISSUES = 5;
-const VALIDATION_ISSUE_FORMAT = {
-	max: VALIDATION_MAX_ISSUES,
-	formatIssue: (issue) => `${formatZodIssuePointer(issue.path)}: ${issue.message}`
-};
-const RESPONSE_SHAPE_ISSUE_FORMAT = {
-	max: RESPONSE_SHAPE_MAX_ISSUES,
-	formatIssue: formatZodIssue
-};
-function formatIssueLines(issues, format) {
-	const head = issues.slice(0, format.max).map(format.formatIssue);
-	const overflow = issues.length - format.max;
-	if (overflow > 0) head.push(`... and ${overflow} more`);
-	return head.map((line) => `  ${line}`).join("\n");
-}
-function formatZodIssuePointer(path) {
-	if (path.length === 0) return "/";
-	return path.map((key) => `/${escapeJsonPointerSegment(key)}`).join("");
-}
-const RESPONSE_SHAPE_LEAD_UNKNOWN_VERSION = "Metabase returned unexpected response shape";
-var ResponseShapeError = class ResponseShapeError extends MetabaseError {
-	category = "response-shape";
-	isRetryable = false;
-	developerDetail;
-	constructor(message, developerDetail) {
-		super(message);
-		this.name = "ResponseShapeError";
-		this.developerDetail = developerDetail;
-	}
-	static fromZodIssues(developerDetail) {
-		return new ResponseShapeError(formatResponseShapeMessage(developerDetail.zodIssues, developerDetail.serverTag), developerDetail);
-	}
-};
-function formatResponseShapeMessage(issues, serverTag) {
-	const lead = serverTag === null ? RESPONSE_SHAPE_LEAD_UNKNOWN_VERSION : `On Metabase ${serverTag} the response shape was unexpected`;
-	if (issues.length === 0) return lead;
-	return `${lead}:\n${formatIssueLines(issues, RESPONSE_SHAPE_ISSUE_FORMAT)}`;
-}
-var ConfigError = class extends MetabaseError {
-	category = "config";
-	isRetryable = false;
-	developerDetail = null;
-	constructor(message) {
-		super(message);
-		this.name = "ConfigError";
-	}
-};
-var InternalError = class extends MetabaseError {
-	category = "internal";
-	isRetryable = false;
-	developerDetail = null;
-	constructor(message) {
-		super(message);
-		this.name = "InternalError";
-	}
-};
-var AbortError = class extends MetabaseError {
-	category = "abort";
-	isRetryable = false;
-	developerDetail = null;
-	constructor(message = "aborted") {
-		super(message);
-		this.name = "AbortError";
-	}
-};
-var ChainedRequestError = class extends MetabaseError {
-	cause;
-	constructor(message, cause) {
-		super(message);
-		this.name = "ChainedRequestError";
-		this.cause = cause;
-	}
-	get category() {
-		return this.cause.category;
-	}
-	get isRetryable() {
-		return this.cause.isRetryable;
-	}
-	get developerDetail() {
-		return this.cause.developerDetail;
-	}
-};
-var UnknownError = class extends MetabaseError {
-	category = "unknown";
-	isRetryable = false;
-	developerDetail;
-	constructor(input) {
-		super(input.originalMessage);
-		this.name = "UnknownError";
-		this.developerDetail = input;
-	}
-};
-function toMetabaseError(error) {
-	if (error instanceof MetabaseError) return error;
-	if (error instanceof ZodError) return new ConfigError(error.issues.map(formatZodIssue).join("; "));
-	if (error instanceof Error) return new UnknownError({
-		originalMessage: error.message,
-		stack: error.stack ?? null
-	});
-	return new UnknownError({
-		originalMessage: String(error),
-		stack: null
-	});
-}
-function formatZodIssue(issue) {
-	const path = core.toDotPath(issue.path);
-	return path === "" ? issue.message : `${path}: ${issue.message}`;
-}
-function isFileNotFoundError(value) {
-	return value instanceof Error && "code" in value && value.code === "ENOENT";
-}
-function errorMessage(value) {
-	return value instanceof Error ? value.message : String(value);
-}
-//#endregion
-//#region ../client/src/predicates.ts
-function isPlainObject(value) {
-	return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-//#endregion
-export { InternalError as a, ResponseShapeError as c, ValidationError as d, errorMessage as f, escapeJsonPointerSegment as h, ConfigError as i, TimeoutError as l, toMetabaseError as m, AbortError as n, MetabaseError as o, isFileNotFoundError as p, ChainedRequestError as r, NetworkError as s, isPlainObject as t, UnknownError as u };