@metabase/client 0.0.0-stage → 0.1.0

package/dist/oauth-login-D734Jvbq.js

@@ -0,0 +1,179 @@
+import { ConfigError } from "./errors.js";
+import { oauthCredentialFromTokens } from "./auth/credential.js";
+import { OAUTH_SCOPE, discoverLoginMetadata, exchangeCode, registerClient } from "./http/oauth.js";
+import { createServer } from "node:http";
+import { createHash, randomBytes } from "node:crypto";
+//#region src/auth/callback-server.ts
+const LOOPBACK_HOST = "127.0.0.1";
+const CALLBACK_PATH = "/callback";
+const DEFAULT_TIMEOUT_MS = 3e5;
+function parseCallbackQuery(rawUrl) {
+	const queryStart = rawUrl.indexOf("?");
+	const params = new URLSearchParams(queryStart === -1 ? "" : rawUrl.slice(queryStart + 1));
+	return {
+		code: params.get("code"),
+		state: params.get("state"),
+		error: params.get("error"),
+		errorDescription: params.get("error_description")
+	};
+}
+function isCallbackPath(rawUrl) {
+	const queryStart = rawUrl.indexOf("?");
+	return (queryStart === -1 ? rawUrl : rawUrl.slice(0, queryStart)) === CALLBACK_PATH;
+}
+function escapeHtml(value) {
+	return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+}
+function htmlPage(title, message) {
+	return "<!DOCTYPE html><html><head><meta charset=\"utf-8\"><title>" + escapeHtml(title) + "</title></head><body style=\"font-family:system-ui;text-align:center;padding-top:4rem;color:#4c5773\"><h1>" + escapeHtml(title) + "</h1><p>" + escapeHtml(message) + "</p><p>You can close this tab and return to your terminal.</p></body></html>";
+}
+function respond(res, status, title, message) {
+	res.writeHead(status, {
+		"content-type": "text/html; charset=utf-8",
+		connection: "close"
+	});
+	res.end(htmlPage(title, message));
+}
+function serverPort(server) {
+	const address = server.address();
+	if (address === null || typeof address === "string") throw new ConfigError("could not determine loopback callback port");
+	return address.port;
+}
+function startCallbackServer(expectedState, timeoutMs = DEFAULT_TIMEOUT_MS) {
+	return new Promise((resolveServer, rejectServer) => {
+		let settle = null;
+		let fail = null;
+		let outcome = null;
+		const server = createServer((req, res) => {
+			const rawUrl = req.url ?? "";
+			if (!isCallbackPath(rawUrl)) {
+				respond(res, 404, "Not found", "Unexpected request.");
+				return;
+			}
+			const query = parseCallbackQuery(rawUrl);
+			if (query.state !== expectedState) {
+				respond(res, 400, "Login failed", "Invalid or missing state.");
+				return;
+			}
+			if (query.error !== null) {
+				const detail = query.errorDescription ?? query.error;
+				respond(res, 400, "Login failed", detail);
+				deliver(new ConfigError(`authorization denied: ${detail}`));
+				return;
+			}
+			if (query.code === null) {
+				respond(res, 400, "Login failed", "Missing authorization code.");
+				deliver(new ConfigError("authorization callback missing code"));
+				return;
+			}
+			respond(res, 200, "Login complete", "Authorization complete. You can close this window.");
+			deliver({
+				code: query.code,
+				state: query.state
+			});
+		});
+		function deliver(result) {
+			if (outcome !== null) return;
+			outcome = result;
+			if (result instanceof Error) fail?.(result);
+			else settle?.(result);
+		}
+		const timer = setTimeout(() => {
+			deliver(new ConfigError(`timed out waiting for browser login after ${timeoutMs}ms`));
+		}, timeoutMs);
+		timer.unref();
+		server.on("error", (error) => {
+			rejectServer(error);
+			deliver(error);
+		});
+		server.listen(0, LOOPBACK_HOST, () => {
+			const port = serverPort(server);
+			resolveServer({
+				redirectUri: `http://${LOOPBACK_HOST}:${port}${CALLBACK_PATH}`,
+				waitForCallback() {
+					return new Promise((resolve, reject) => {
+						if (outcome !== null) {
+							if (outcome instanceof Error) reject(outcome);
+							else resolve(outcome);
+							return;
+						}
+						settle = resolve;
+						fail = reject;
+					});
+				},
+				close() {
+					clearTimeout(timer);
+					server.close();
+					server.closeAllConnections();
+				}
+			});
+		});
+	});
+}
+//#endregion
+//#region src/auth/pkce.ts
+const VERIFIER_BYTES = 32;
+const STATE_BYTES = 16;
+function base64Url(buffer) {
+	return buffer.toString("base64url");
+}
+function generatePkce() {
+	const verifier = base64Url(randomBytes(VERIFIER_BYTES));
+	return {
+		verifier,
+		challenge: base64Url(createHash("sha256").update(verifier).digest())
+	};
+}
+function randomState() {
+	return base64Url(randomBytes(STATE_BYTES));
+}
+//#endregion
+//#region src/auth/oauth-login.ts
+function buildAuthorizeUrl(authorizationEndpoint, params) {
+	return `${authorizationEndpoint}${authorizationEndpoint.includes("?") ? "&" : "?"}${new URLSearchParams(params).toString()}`;
+}
+async function resolveClientId(input, registrationEndpoint, redirectUri) {
+	if (input.clientId !== void 0) return input.clientId;
+	if (registrationEndpoint === void 0) throw new ConfigError("this Metabase has dynamic client registration disabled; pass clientId with a pre-registered native client");
+	return (await registerClient({
+		registrationEndpoint,
+		redirectUri,
+		clientName: input.clientName,
+		userAgent: input.userAgent
+	})).client_id;
+}
+async function oauthLogin(input, deps) {
+	const metadata = input.metadata ?? await discoverLoginMetadata(input.baseUrl, input.userAgent);
+	const pkce = generatePkce();
+	const state = randomState();
+	const server = await startCallbackServer(state, input.timeoutMs);
+	try {
+		const clientId = await resolveClientId(input, metadata.registration_endpoint, server.redirectUri);
+		const authorizeUrl = buildAuthorizeUrl(metadata.authorization_endpoint, {
+			response_type: "code",
+			client_id: clientId,
+			redirect_uri: server.redirectUri,
+			code_challenge: pkce.challenge,
+			code_challenge_method: "S256",
+			state,
+			scope: OAUTH_SCOPE
+		});
+		const opened = await deps.openBrowser(authorizeUrl);
+		deps.onAuthorizeUrl(authorizeUrl, opened);
+		const callback = await server.waitForCallback();
+		const tokens = await exchangeCode({
+			tokenEndpoint: metadata.token_endpoint,
+			code: callback.code,
+			redirectUri: server.redirectUri,
+			clientId,
+			codeVerifier: pkce.verifier,
+			userAgent: input.userAgent
+		});
+		if (tokens.refresh_token === void 0) throw new ConfigError("token endpoint did not return a refresh token");
+		return oauthCredentialFromTokens(tokens, tokens.refresh_token, clientId, deps.now());
+	} finally {
+		server.close();
+	}
+}
+//#endregion
+export { oauthLogin as t };

package/dist/oauth-session-BlIlcd8Q.d.ts

@@ -0,0 +1,6 @@
+import { c as OAuthCredential } from "./credential-6aOEGqMH.js";
+//#region src/auth/oauth-session.d.ts
+declare function refreshOAuthCredential(baseUrl: string, credential: OAuthCredential, nowMs: number, userAgent: string): Promise<OAuthCredential>;
+declare function revokeOAuthCredential(baseUrl: string, credential: OAuthCredential, userAgent: string): Promise<boolean>;
+//#endregion
+export { revokeOAuthCredential as n, refreshOAuthCredential as t };

package/dist/paginate-DZWvWvbm.d.ts

@@ -0,0 +1,24 @@
+import { d as QueryValue, h as Transport } from "./transport-E0ZaPNWJ.js";
+import { ZodType } from "zod";
+//#region src/paginate.d.ts
+declare const DEFAULT_PAGE_SIZE = 50;
+interface PaginateOptions {
+  query?: Record<string, QueryValue>;
+  pageSize?: number;
+  offset?: number;
+  max?: number;
+  signal?: AbortSignal;
+}
+interface Page<T> {
+  items: T[];
+  total: number | null;
+}
+interface PaginatedEnvelope<T> {
+  data: T[];
+  total?: number | null | undefined;
+  limit?: number | undefined;
+  offset?: number | undefined;
+}
+declare function paginatePages<T>(client: Transport, path: string, itemSchema: ZodType<T>, opts?: PaginateOptions): AsyncIterable<Page<T>>;
+//#endregion
+export { paginatePages as a, PaginatedEnvelope as i, Page as n, PaginateOptions as r, DEFAULT_PAGE_SIZE as t };

package/dist/paginate.d.ts

@@ -0,0 +1,2 @@
+import { a as paginatePages, i as PaginatedEnvelope, n as Page, r as PaginateOptions, t as DEFAULT_PAGE_SIZE } from "./paginate-DZWvWvbm.js";
+export { DEFAULT_PAGE_SIZE, Page, PaginateOptions, PaginatedEnvelope, paginatePages };

package/dist/paginate.js

@@ -0,0 +1,49 @@
+import { ConfigError, InternalError } from "./errors.js";
+import { z } from "zod";
+//#region src/paginate.ts
+const DEFAULT_PAGE_SIZE = 50;
+async function* paginatePages(client, path, itemSchema, opts = {}) {
+	const envelopeSchema = paginatedEnvelopeSchema(itemSchema);
+	const pageSize = opts.pageSize ?? 50;
+	if (!Number.isInteger(pageSize) || pageSize < 1) throw new InternalError(`pageSize must be an integer of at least 1, got ${pageSize}`);
+	const start = opts.offset ?? 0;
+	const max = opts.max ?? Number.POSITIVE_INFINITY;
+	let taken = 0;
+	let previousHead = null;
+	while (taken < max) {
+		const remaining = max - taken;
+		const limit = Math.min(pageSize, remaining);
+		const offset = start + taken;
+		const envelope = await client.requestParsed(envelopeSchema, path, {
+			query: {
+				...opts.query,
+				limit,
+				offset
+			},
+			...opts.signal !== void 0 && { signal: opts.signal }
+		});
+		const items = envelope.data.length > remaining ? envelope.data.slice(0, remaining) : envelope.data;
+		const total = envelope.total ?? null;
+		const head = items.length === 0 ? null : JSON.stringify(items[0]);
+		if (head !== null && head === previousHead) throw new ConfigError(`the endpoint returned the same first row at offset ${offset} as at the previous offset; it is ignoring the offset parameter, so paging cannot advance`);
+		previousHead = head;
+		yield {
+			items,
+			total
+		};
+		if (items.length === 0) return;
+		const consumed = taken + items.length;
+		if (total !== null && start + consumed === total) return;
+		taken = consumed;
+	}
+}
+function paginatedEnvelopeSchema(itemSchema) {
+	return z.object({
+		data: z.array(itemSchema),
+		total: z.number().int().nonnegative().nullable().optional(),
+		limit: z.number().int().nonnegative().optional(),
+		offset: z.number().int().nonnegative().optional()
+	}).loose();
+}
+//#endregion
+export { DEFAULT_PAGE_SIZE, paginatePages };

package/dist/parameter-ak-J-IOj.d.ts

@@ -0,0 +1,190 @@
+import { z } from "zod";
+//#region src/domain/parameter.d.ts
+declare const ParameterType: z.ZodEnum<{
+  number: "number";
+  boolean: "boolean";
+  id: "id";
+  date: "date";
+  text: "text";
+  "temporal-unit": "temporal-unit";
+  "date/single": "date/single";
+  category: "category";
+  "location/city": "location/city";
+  "location/state": "location/state";
+  "location/zip_code": "location/zip_code";
+  "location/country": "location/country";
+  "date/range": "date/range";
+  "date/month-year": "date/month-year";
+  "date/quarter-year": "date/quarter-year";
+  "date/relative": "date/relative";
+  "date/all-options": "date/all-options";
+  "number/!=": "number/!=";
+  "number/<=": "number/<=";
+  "number/=": "number/=";
+  "number/>=": "number/>=";
+  "number/between": "number/between";
+  "string/!=": "string/!=";
+  "string/=": "string/=";
+  "string/contains": "string/contains";
+  "string/does-not-contain": "string/does-not-contain";
+  "string/ends-with": "string/ends-with";
+  "string/starts-with": "string/starts-with";
+  "boolean/=": "boolean/=";
+}>;
+type ParameterType = z.infer<typeof ParameterType>;
+declare const TemporalUnit: z.ZodEnum<{
+  default: "default";
+  millisecond: "millisecond";
+  second: "second";
+  minute: "minute";
+  hour: "hour";
+  day: "day";
+  week: "week";
+  month: "month";
+  quarter: "quarter";
+  year: "year";
+  "second-of-minute": "second-of-minute";
+  "minute-of-hour": "minute-of-hour";
+  "hour-of-day": "hour-of-day";
+  "day-of-week": "day-of-week";
+  "day-of-month": "day-of-month";
+  "day-of-year": "day-of-year";
+  "week-of-year": "week-of-year";
+  "month-of-year": "month-of-year";
+  "quarter-of-year": "quarter-of-year";
+  "year-of-era": "year-of-era";
+}>;
+type TemporalUnit = z.infer<typeof TemporalUnit>;
+declare const ValuesSourceType: z.ZodEnum<{
+  card: "card";
+  "static-list": "static-list";
+}>;
+type ValuesSourceType = z.infer<typeof ValuesSourceType>;
+declare const ValuesQueryType: z.ZodEnum<{
+  list: "list";
+  search: "search";
+  none: "none";
+}>;
+type ValuesQueryType = z.infer<typeof ValuesQueryType>;
+declare const ParameterTemplateTagRef: z.ZodTuple<[z.ZodLiteral<"template-tag">, z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+  id: z.ZodString;
+}, z.core.$loose>]>], null>;
+declare const ParameterTextTagTarget: z.ZodTuple<[z.ZodLiteral<"text-tag">, z.ZodString], null>;
+declare const ParameterTarget: z.ZodUnion<readonly [z.ZodTuple<[z.ZodLiteral<"dimension">, z.ZodUnion<readonly [z.ZodTuple<[z.ZodLiteral<"template-tag">, z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+  id: z.ZodString;
+}, z.core.$loose>]>], null>, z.ZodTuple<[z.ZodString], z.ZodUnknown>]>], z.ZodUnknown>, z.ZodTuple<[z.ZodLiteral<"variable">, z.ZodUnion<readonly [z.ZodTuple<[z.ZodLiteral<"template-tag">, z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+  id: z.ZodString;
+}, z.core.$loose>]>], null>, z.ZodTuple<[z.ZodString], z.ZodUnknown>]>], null>, z.ZodTuple<[z.ZodLiteral<"text-tag">, z.ZodString], null>, z.ZodNumber, z.ZodTuple<[z.ZodString], z.ZodUnknown>]>;
+type ParameterTarget = z.infer<typeof ParameterTarget>;
+declare const ValuesSourceConfig: z.ZodObject<{
+  values: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
+  card_id: z.ZodOptional<z.ZodNumber>;
+  value_field: z.ZodOptional<z.ZodTuple<[z.ZodString], z.ZodUnknown>>;
+  label_field: z.ZodOptional<z.ZodTuple<[z.ZodString], z.ZodUnknown>>;
+}, z.core.$loose>;
+type ValuesSourceConfig = z.infer<typeof ValuesSourceConfig>;
+declare const Parameter: z.ZodObject<{
+  id: z.ZodString;
+  type: z.ZodEnum<{
+    number: "number";
+    boolean: "boolean";
+    id: "id";
+    date: "date";
+    text: "text";
+    "temporal-unit": "temporal-unit";
+    "date/single": "date/single";
+    category: "category";
+    "location/city": "location/city";
+    "location/state": "location/state";
+    "location/zip_code": "location/zip_code";
+    "location/country": "location/country";
+    "date/range": "date/range";
+    "date/month-year": "date/month-year";
+    "date/quarter-year": "date/quarter-year";
+    "date/relative": "date/relative";
+    "date/all-options": "date/all-options";
+    "number/!=": "number/!=";
+    "number/<=": "number/<=";
+    "number/=": "number/=";
+    "number/>=": "number/>=";
+    "number/between": "number/between";
+    "string/!=": "string/!=";
+    "string/=": "string/=";
+    "string/contains": "string/contains";
+    "string/does-not-contain": "string/does-not-contain";
+    "string/ends-with": "string/ends-with";
+    "string/starts-with": "string/starts-with";
+    "boolean/=": "boolean/=";
+  }>;
+  name: z.ZodOptional<z.ZodString>;
+  slug: z.ZodOptional<z.ZodString>;
+  sectionId: z.ZodOptional<z.ZodString>;
+  default: z.ZodOptional<z.ZodUnknown>;
+  required: z.ZodOptional<z.ZodNullable<z.ZodBoolean>>;
+  filteringParameters: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+  target: z.ZodOptional<z.ZodUnion<readonly [z.ZodTuple<[z.ZodLiteral<"dimension">, z.ZodUnion<readonly [z.ZodTuple<[z.ZodLiteral<"template-tag">, z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+    id: z.ZodString;
+  }, z.core.$loose>]>], null>, z.ZodTuple<[z.ZodString], z.ZodUnknown>]>], z.ZodUnknown>, z.ZodTuple<[z.ZodLiteral<"variable">, z.ZodUnion<readonly [z.ZodTuple<[z.ZodLiteral<"template-tag">, z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+    id: z.ZodString;
+  }, z.core.$loose>]>], null>, z.ZodTuple<[z.ZodString], z.ZodUnknown>]>], null>, z.ZodTuple<[z.ZodLiteral<"text-tag">, z.ZodString], null>, z.ZodNumber, z.ZodTuple<[z.ZodString], z.ZodUnknown>]>>;
+  temporal_units: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodEnum<{
+    default: "default";
+    millisecond: "millisecond";
+    second: "second";
+    minute: "minute";
+    hour: "hour";
+    day: "day";
+    week: "week";
+    month: "month";
+    quarter: "quarter";
+    year: "year";
+    "second-of-minute": "second-of-minute";
+    "minute-of-hour": "minute-of-hour";
+    "hour-of-day": "hour-of-day";
+    "day-of-week": "day-of-week";
+    "day-of-month": "day-of-month";
+    "day-of-year": "day-of-year";
+    "week-of-year": "week-of-year";
+    "month-of-year": "month-of-year";
+    "quarter-of-year": "quarter-of-year";
+    "year-of-era": "year-of-era";
+  }>>>>;
+  values_query_type: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+    list: "list";
+    search: "search";
+    none: "none";
+  }>>>;
+  values_source_type: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+    card: "card";
+    "static-list": "static-list";
+  }>>>;
+  values_source_config: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+    values: z.ZodOptional<z.ZodArray<z.ZodUnknown>>;
+    card_id: z.ZodOptional<z.ZodNumber>;
+    value_field: z.ZodOptional<z.ZodTuple<[z.ZodString], z.ZodUnknown>>;
+    label_field: z.ZodOptional<z.ZodTuple<[z.ZodString], z.ZodUnknown>>;
+  }, z.core.$loose>>>;
+}, z.core.$loose>;
+type Parameter = z.infer<typeof Parameter>;
+declare const ParameterMapping: z.ZodObject<{
+  parameter_id: z.ZodString;
+  target: z.ZodUnion<readonly [z.ZodTuple<[z.ZodLiteral<"dimension">, z.ZodUnion<readonly [z.ZodTuple<[z.ZodLiteral<"template-tag">, z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+    id: z.ZodString;
+  }, z.core.$loose>]>], null>, z.ZodTuple<[z.ZodString], z.ZodUnknown>]>], z.ZodUnknown>, z.ZodTuple<[z.ZodLiteral<"variable">, z.ZodUnion<readonly [z.ZodTuple<[z.ZodLiteral<"template-tag">, z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+    id: z.ZodString;
+  }, z.core.$loose>]>], null>, z.ZodTuple<[z.ZodString], z.ZodUnknown>]>], null>, z.ZodTuple<[z.ZodLiteral<"text-tag">, z.ZodString], null>, z.ZodNumber, z.ZodTuple<[z.ZodString], z.ZodUnknown>]>;
+  card_id: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+}, z.core.$loose>;
+type ParameterMapping = z.infer<typeof ParameterMapping>;
+declare const ParameterValues: z.ZodObject<{
+  values: z.ZodArray<z.ZodArray<z.ZodUnknown>>;
+  has_more_values: z.ZodBoolean;
+}, z.core.$loose>;
+type ParameterValues = z.infer<typeof ParameterValues>;
+declare const ParameterValuesCompact: z.ZodObject<{
+  values: z.ZodArray<z.ZodArray<z.ZodUnknown>>;
+  has_more_values: z.ZodBoolean;
+}, z.core.$strip>;
+type ParameterValuesCompact = z.infer<typeof ParameterValuesCompact>;
+//#endregion
+export { ParameterTextTagTarget as a, ParameterValuesCompact as c, ValuesSourceConfig as d, ValuesSourceType as f, ParameterTemplateTagRef as i, TemporalUnit as l, ParameterMapping as n, ParameterType as o, ParameterTarget as r, ParameterValues as s, Parameter as t, ValuesQueryType as u };

package/dist/permission-BnCQw5Kp.d.ts

@@ -0,0 +1,149 @@
+import { z } from "zod";
+//#region src/domain/permission.d.ts
+declare const ViewDataPermission: z.ZodEnum<{
+  unrestricted: "unrestricted";
+  "legacy-no-self-service": "legacy-no-self-service";
+  blocked: "blocked";
+  sandboxed: "sandboxed";
+  impersonated: "impersonated";
+}>;
+type ViewDataPermission = z.infer<typeof ViewDataPermission>;
+declare const CreateQueriesPermission: z.ZodEnum<{
+  "query-builder-and-native": "query-builder-and-native";
+  "query-builder": "query-builder";
+  no: "no";
+}>;
+type CreateQueriesPermission = z.infer<typeof CreateQueriesPermission>;
+declare const DownloadPermission: z.ZodEnum<{
+  full: "full";
+  limited: "limited";
+}>;
+type DownloadPermission = z.infer<typeof DownloadPermission>;
+declare const DataModelPermission: z.ZodLiteral<"all">;
+type DataModelPermission = z.infer<typeof DataModelPermission>;
+declare const YesNoPermission: z.ZodEnum<{
+  no: "no";
+  yes: "yes";
+}>;
+type YesNoPermission = z.infer<typeof YesNoPermission>;
+declare const DatabasePermissions: z.ZodObject<{
+  "view-data": z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
+    unrestricted: "unrestricted";
+    "legacy-no-self-service": "legacy-no-self-service";
+    blocked: "blocked";
+    sandboxed: "sandboxed";
+    impersonated: "impersonated";
+  }>, z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodEnum<{
+    unrestricted: "unrestricted";
+    "legacy-no-self-service": "legacy-no-self-service";
+    blocked: "blocked";
+    sandboxed: "sandboxed";
+    impersonated: "impersonated";
+  }>, z.ZodRecord<z.ZodString, z.ZodEnum<{
+    unrestricted: "unrestricted";
+    "legacy-no-self-service": "legacy-no-self-service";
+    blocked: "blocked";
+    sandboxed: "sandboxed";
+    impersonated: "impersonated";
+  }>>]>>]>>;
+  "create-queries": z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
+    "query-builder-and-native": "query-builder-and-native";
+    "query-builder": "query-builder";
+    no: "no";
+  }>, z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodEnum<{
+    "query-builder-and-native": "query-builder-and-native";
+    "query-builder": "query-builder";
+    no: "no";
+  }>, z.ZodRecord<z.ZodString, z.ZodEnum<{
+    "query-builder-and-native": "query-builder-and-native";
+    "query-builder": "query-builder";
+    no: "no";
+  }>>]>>]>>;
+  download: z.ZodOptional<z.ZodObject<{
+    schemas: z.ZodUnion<readonly [z.ZodEnum<{
+      full: "full";
+      limited: "limited";
+    }>, z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodEnum<{
+      full: "full";
+      limited: "limited";
+    }>, z.ZodRecord<z.ZodString, z.ZodEnum<{
+      full: "full";
+      limited: "limited";
+    }>>]>>]>;
+  }, z.core.$loose>>;
+  "data-model": z.ZodOptional<z.ZodObject<{
+    schemas: z.ZodUnion<readonly [z.ZodLiteral<"all">, z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodLiteral<"all">, z.ZodRecord<z.ZodString, z.ZodLiteral<"all">>]>>]>;
+  }, z.core.$loose>>;
+  details: z.ZodOptional<z.ZodEnum<{
+    no: "no";
+    yes: "yes";
+  }>>;
+  transforms: z.ZodOptional<z.ZodEnum<{
+    no: "no";
+    yes: "yes";
+  }>>;
+}, z.core.$loose>;
+type DatabasePermissions = z.infer<typeof DatabasePermissions>;
+declare const PermissionsGraph: z.ZodObject<{
+  revision: z.ZodNumber;
+  groups: z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodObject<{
+    "view-data": z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
+      unrestricted: "unrestricted";
+      "legacy-no-self-service": "legacy-no-self-service";
+      blocked: "blocked";
+      sandboxed: "sandboxed";
+      impersonated: "impersonated";
+    }>, z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodEnum<{
+      unrestricted: "unrestricted";
+      "legacy-no-self-service": "legacy-no-self-service";
+      blocked: "blocked";
+      sandboxed: "sandboxed";
+      impersonated: "impersonated";
+    }>, z.ZodRecord<z.ZodString, z.ZodEnum<{
+      unrestricted: "unrestricted";
+      "legacy-no-self-service": "legacy-no-self-service";
+      blocked: "blocked";
+      sandboxed: "sandboxed";
+      impersonated: "impersonated";
+    }>>]>>]>>;
+    "create-queries": z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
+      "query-builder-and-native": "query-builder-and-native";
+      "query-builder": "query-builder";
+      no: "no";
+    }>, z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodEnum<{
+      "query-builder-and-native": "query-builder-and-native";
+      "query-builder": "query-builder";
+      no: "no";
+    }>, z.ZodRecord<z.ZodString, z.ZodEnum<{
+      "query-builder-and-native": "query-builder-and-native";
+      "query-builder": "query-builder";
+      no: "no";
+    }>>]>>]>>;
+    download: z.ZodOptional<z.ZodObject<{
+      schemas: z.ZodUnion<readonly [z.ZodEnum<{
+        full: "full";
+        limited: "limited";
+      }>, z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodEnum<{
+        full: "full";
+        limited: "limited";
+      }>, z.ZodRecord<z.ZodString, z.ZodEnum<{
+        full: "full";
+        limited: "limited";
+      }>>]>>]>;
+    }, z.core.$loose>>;
+    "data-model": z.ZodOptional<z.ZodObject<{
+      schemas: z.ZodUnion<readonly [z.ZodLiteral<"all">, z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodLiteral<"all">, z.ZodRecord<z.ZodString, z.ZodLiteral<"all">>]>>]>;
+    }, z.core.$loose>>;
+    details: z.ZodOptional<z.ZodEnum<{
+      no: "no";
+      yes: "yes";
+    }>>;
+    transforms: z.ZodOptional<z.ZodEnum<{
+      no: "no";
+      yes: "yes";
+    }>>;
+  }, z.core.$loose>>>;
+}, z.core.$loose>;
+type PermissionsGraph = z.infer<typeof PermissionsGraph>;
+//#endregion
+export { PermissionsGraph as a, DownloadPermission as i, DataModelPermission as n, ViewDataPermission as o, DatabasePermissions as r, YesNoPermission as s, CreateQueriesPermission as t };

package/dist/poll-CIwnee7h.d.ts

@@ -0,0 +1,15 @@
+//#region src/poll.d.ts
+type Backoff = "fixed" | "exponential";
+interface PollOptions {
+  intervalMs?: number;
+  maxIntervalMs?: number;
+  timeoutMs?: number;
+  backoff?: Backoff;
+  signal?: AbortSignal;
+}
+declare const DEFAULT_INTERVAL_MS = 2000;
+declare const DEFAULT_MAX_INTERVAL_MS = 30000;
+declare const DEFAULT_TIMEOUT_MS = 600000;
+declare function pollUntil<T>(fn: (signal: AbortSignal) => Promise<T>, done: (value: T) => boolean, opts?: PollOptions): Promise<T>;
+//#endregion
+export { PollOptions as a, DEFAULT_TIMEOUT_MS as i, DEFAULT_INTERVAL_MS as n, pollUntil as o, DEFAULT_MAX_INTERVAL_MS as r, Backoff as t };

package/dist/poll.d.ts

@@ -0,0 +1,2 @@
+import { a as PollOptions, i as DEFAULT_TIMEOUT_MS, n as DEFAULT_INTERVAL_MS, o as pollUntil, r as DEFAULT_MAX_INTERVAL_MS, t as Backoff } from "./poll-CIwnee7h.js";
+export { Backoff, DEFAULT_INTERVAL_MS, DEFAULT_MAX_INTERVAL_MS, DEFAULT_TIMEOUT_MS, PollOptions, pollUntil };

package/dist/poll.js

@@ -0,0 +1,47 @@
+import { TimeoutError } from "./errors.js";
+import { combineAborts, throwIfAborted } from "./signal.js";
+import { setTimeout } from "node:timers/promises";
+//#region src/poll.ts
+const DEFAULT_INTERVAL_MS = 2e3;
+const DEFAULT_MAX_INTERVAL_MS = 3e4;
+const DEFAULT_TIMEOUT_MS = 6e5;
+async function pollUntil(fn, done, opts = {}) {
+	const intervalMs = opts.intervalMs ?? 2e3;
+	const maxIntervalMs = opts.maxIntervalMs ?? 3e4;
+	const timeoutMs = opts.timeoutMs ?? 6e5;
+	const backoff = opts.backoff ?? "fixed";
+	const combined = combineAborts(AbortSignal.timeout(timeoutMs), opts.signal);
+	let interval = intervalMs;
+	let attempts = 0;
+	while (true) {
+		throwIfAborted(opts.signal);
+		if (combined.aborted) throw pollTimeout(timeoutMs, attempts);
+		let value;
+		try {
+			value = await fn(combined);
+		} catch (error) {
+			throwIfAborted(opts.signal);
+			if (combined.aborted) throw pollTimeout(timeoutMs, attempts);
+			throw error;
+		}
+		attempts += 1;
+		if (done(value)) return value;
+		try {
+			await setTimeout(interval, void 0, { signal: combined });
+		} catch (error) {
+			throwIfAborted(opts.signal);
+			if (combined.aborted) throw pollTimeout(timeoutMs, attempts);
+			throw error;
+		}
+		if (backoff === "exponential") interval = Math.min(interval * 2, maxIntervalMs);
+	}
+}
+function pollTimeout(timeoutMs, attempts) {
+	return new TimeoutError(`Polling timed out after ${timeoutMs}ms`, {
+		kind: "polling",
+		timeoutMs,
+		attempts
+	});
+}
+//#endregion
+export { DEFAULT_INTERVAL_MS, DEFAULT_MAX_INTERVAL_MS, DEFAULT_TIMEOUT_MS, pollUntil };