better-supabase 0.5.0 → 0.6.0

package/dist/stats-Bqob3WqT.js

@@ -1,592 +0,0 @@
-import { c as mapDbError, n as dbError } from "./errors-DtwXa6b8.js";
-import { a as invalidRequest, n as simplifyOrFalse } from "./simplify-_0oUKqCd.js";
-import { i as temporalText } from "./temporal-CVlIV2DZ.js";
-import { i as ok, n as err, o as toDbError } from "./result-BKiliPY7.js";
-//#region src/compile/postgrest.ts
-function scalar(value) {
-	if (typeof value === "string") return value;
-	if (typeof value === "number" || typeof value === "boolean") return String(value);
-	const temporalValue = temporalText(value);
-	if (temporalValue !== void 0) return temporalValue;
-	if (typeof value === "number" || typeof value === "bigint" || typeof value === "boolean") return String(value);
-	if (value === null) return "null";
-	return JSON.stringify(value);
-}
-/** Double-quotes a value for PostgREST lists and logic trees. */
-function quote(value) {
-	return `"${scalar(value).replaceAll("\\", "\\\\").replaceAll("\"", "\\\"")}"`;
-}
-function list(values, open, close) {
-	return `${open}${values.map(quote).join(",")}${close}`;
-}
-function isBoolLike(value) {
-	return value === null || typeof value === "boolean";
-}
-function operatorAndValue(condition, inLogic) {
-	const { op, value } = condition;
-	const plain = (text) => inLogic ? quote(text) : scalar(text);
-	switch (op) {
-		case "eq":
-		case "neq":
-		case "gt":
-		case "gte":
-		case "lt":
-		case "lte":
-		case "like":
-		case "ilike": return {
-			operator: op,
-			value: plain(value)
-		};
-		case "in":
-			if (!Array.isArray(value)) invalidRequest("\"in\" needs an array");
-			return {
-				operator: "in",
-				value: list(value, "(", ")")
-			};
-		case "is":
-			if (!isBoolLike(value)) invalidRequest("\"is\" needs null, true or false");
-			return {
-				operator: "is",
-				value: String(value)
-			};
-		case "contains":
-		case "containedBy":
-		case "overlaps": {
-			const operator = op === "contains" ? "cs" : op === "containedBy" ? "cd" : "ov";
-			if (Array.isArray(value)) return {
-				operator,
-				value: list(value, "{", "}")
-			};
-			const json = JSON.stringify(value);
-			return {
-				operator,
-				value: inLogic ? quote(json) : json
-			};
-		}
-		case "fts": return {
-			operator: condition.config ? `wfts(${condition.config})` : "wfts",
-			value: plain(value)
-		};
-		default: return op;
-	}
-}
-var PostgrestCompiler = class {
-	filters = [];
-	orders = [];
-	limits = [];
-	#counter = 0;
-	nextAlias() {
-		this.#counter += 1;
-		return `_bs${this.#counter}`;
-	}
-	/** Compiles a condition at `path` where top-level items are ANDed. */
-	andContext(condition, path, embeds) {
-		switch (condition.kind) {
-			case "and":
-				for (const item of condition.items) this.andContext(item, path, embeds);
-				return;
-			case "column": {
-				const { operator, value } = operatorAndValue(condition, false);
-				this.filters.push({
-					kind: "filter",
-					path: path ? `${path}.${condition.column}` : condition.column,
-					operator,
-					value
-				});
-				return;
-			}
-			case "not": {
-				const inner = condition.item;
-				if (inner.kind === "column") {
-					const { operator, value } = operatorAndValue(inner, false);
-					this.filters.push({
-						kind: "filter",
-						path: path ? `${path}.${inner.column}` : inner.column,
-						operator: `not.${operator}`,
-						value
-					});
-					return;
-				}
-				if (inner.kind === "relation") {
-					this.relationAnd(negateRelation(inner), path, embeds);
-					return;
-				}
-				if (inner.kind === "not") {
-					this.andContext(inner.item, path, embeds);
-					return;
-				}
-				this.filters.push({
-					kind: "or",
-					expression: this.logic(condition, embeds),
-					referencedTable: path
-				});
-				return;
-			}
-			case "or":
-				this.filters.push({
-					kind: "or",
-					expression: this.logic(condition, embeds).replace(/^or\(/, "").replace(/\)$/, ""),
-					referencedTable: path
-				});
-				return;
-			case "relation":
-				this.relationAnd(condition, path, embeds);
-				return;
-			default: return condition;
-		}
-	}
-	relationAnd(condition, path, embeds) {
-		if (condition.quantifier === "every" && !condition.where) return;
-		const alias = this.nextAlias();
-		const aliasPath = path ? `${path}.${alias}` : alias;
-		const node = filterEmbed(alias, condition, condition.quantifier === "some");
-		this.withPath(node.children, aliasPath);
-		embeds.push(node);
-		const where = condition.quantifier === "every" && condition.where ? {
-			kind: "not",
-			item: condition.where
-		} : condition.where;
-		if (where) this.andContext(where, aliasPath, node.children);
-		if (condition.quantifier !== "some") this.filters.push({
-			kind: "filter",
-			path: aliasPath,
-			operator: "is",
-			value: "null"
-		});
-	}
-	/** Compiles a condition into a PostgREST logic-tree term. */
-	logic(condition, embeds) {
-		switch (condition.kind) {
-			case "and":
-			case "or": return `${condition.kind}(${condition.items.map((item) => this.logic(item, embeds)).join(",")})`;
-			case "not": {
-				const inner = condition.item;
-				if (inner.kind === "column") {
-					const { operator, value } = operatorAndValue(inner, true);
-					return `${inner.column}.not.${operator}.${value}`;
-				}
-				if (inner.kind === "relation") return this.logic(negateRelation(inner), embeds);
-				if (inner.kind === "not") return this.logic(inner.item, embeds);
-				return `not.${this.logic(inner, embeds)}`;
-			}
-			case "column": {
-				const { operator, value } = operatorAndValue(condition, true);
-				return `${condition.column}.${operator}.${value}`;
-			}
-			case "relation": {
-				if (condition.quantifier === "every" && !condition.where) invalidRequest("every({}) must be simplified before compiling");
-				const alias = this.nextAlias();
-				const node = filterEmbed(alias, condition, false);
-				const nodePath = this.pathOf(alias, embeds);
-				this.withPath(node.children, nodePath);
-				embeds.push(node);
-				const where = condition.quantifier === "every" && condition.where ? {
-					kind: "not",
-					item: condition.where
-				} : condition.where;
-				if (where) this.andContext(where, nodePath, node.children);
-				return condition.quantifier === "some" ? `${alias}.not.is.null` : `${alias}.is.null`;
-			}
-			default: return condition;
-		}
-	}
-	#paths = /* @__PURE__ */ new WeakMap();
-	withPath(embeds, path) {
-		this.#paths.set(embeds, path);
-		return embeds;
-	}
-	pathOf(alias, embeds) {
-		const parent = this.#paths.get(embeds);
-		return parent ? `${parent}.${alias}` : alias;
-	}
-	include(include, path, embeds) {
-		const aliasPath = path ? `${path}.${include.alias}` : include.alias;
-		const node = {
-			alias: include.alias,
-			target: include.target,
-			relation: include.relation,
-			inner: include.required,
-			columns: include.selection.columns,
-			children: this.withPath([], aliasPath),
-			...include.count === void 0 ? {} : { count: true },
-			...include.selection.aggregate ? { measures: include.selection.aggregate.measures } : {}
-		};
-		embeds.push(node);
-		for (const child of include.selection.includes) this.include(child, aliasPath, node.children);
-		const where = simplifyOrFalse(include.where);
-		if (where.never) {
-			const [first] = include.target.primaryKey;
-			const column = first ? include.target.columns[first]?.db : void 0;
-			if (!column) invalidRequest(`Cannot filter "${include.alias}" to nothing`);
-			this.filters.push({
-				kind: "filter",
-				path: `${aliasPath}.${column}`,
-				operator: "is",
-				value: "null"
-			}, {
-				kind: "filter",
-				path: `${aliasPath}.${column}`,
-				operator: "not.is",
-				value: "null"
-			});
-		} else if (where.condition) this.andContext(where.condition, aliasPath, node.children);
-		for (const term of include.orderBy) this.order(term, aliasPath);
-		if (include.limit !== void 0) this.limits.push({
-			count: include.limit,
-			referencedTable: aliasPath
-		});
-	}
-	order(term, referencedTable) {
-		this.orders.push({
-			column: term.column,
-			ascending: term.direction === "asc",
-			nullsFirst: term.nulls === void 0 ? void 0 : term.nulls === "first",
-			referencedTable
-		});
-	}
-};
-function negateRelation(condition) {
-	switch (condition.quantifier) {
-		case "some": return {
-			...condition,
-			quantifier: "none"
-		};
-		case "none": return {
-			...condition,
-			quantifier: "some"
-		};
-		case "every": return {
-			...condition,
-			quantifier: "some",
-			where: condition.where ? {
-				kind: "not",
-				item: condition.where
-			} : void 0
-		};
-		default: return condition.quantifier;
-	}
-}
-function filterEmbed(alias, condition, inner) {
-	return {
-		alias,
-		target: condition.target,
-		relation: condition.relation,
-		inner,
-		columns: [],
-		children: []
-	};
-}
-const columnTexts = /* @__PURE__ */ new WeakMap();
-/** The rendered column list, cached per (shared, immutable) column array. */
-function columnText(columns) {
-	let text = columnTexts.get(columns);
-	if (text === void 0) {
-		text = columns.map(({ alias, column, cast }) => {
-			const source = cast ? `${column}::${cast}` : column;
-			return alias === column ? source : `${alias}:${source}`;
-		}).join(",");
-		columnTexts.set(columns, text);
-	}
-	return text;
-}
-function columnList(columns) {
-	return columns.length > 0 ? [columnText(columns)] : [];
-}
-/** `key:column.sum()::text`, PostgREST's aggregate syntax (PostgREST 12+). */
-function measureList(measures) {
-	return measures.map(({ key, column, fn, cast }) => `${key}:${column}.${fn}()${cast ? `::${cast}` : ""}`);
-}
-function aggregateList(aggregate) {
-	return [...aggregate.count ? ["_count:count()"] : [], ...measureList(aggregate.measures)];
-}
-function renderEmbeds(embeds) {
-	return embeds.map((node) => {
-		const hint = `${node.target.name}!${node.relation.foreignKey}${node.inner ? "!inner" : ""}`;
-		if (node.count) return `${node.alias}:${hint}(count)`;
-		if (node.measures) return `${node.alias}:${hint}(${measureList(node.measures).join(",")})`;
-		const inside = [...columnList(node.columns), ...renderEmbeds(node.children)];
-		return `${node.alias}:${hint}(${inside.join(",")})`;
-	});
-}
-function renderSelect(selection, embeds) {
-	if (!selection.aggregate && embeds.length === 0) return selection.columns.length > 0 ? columnText(selection.columns) : "*";
-	const parts = [
-		...columnList(selection.columns),
-		...selection.aggregate ? aggregateList(selection.aggregate) : [],
-		...renderEmbeds(embeds)
-	];
-	return parts.length > 0 ? parts.join(",") : "*";
-}
-function applyWhere(compiler, condition, embeds) {
-	const where = simplifyOrFalse(condition);
-	if (where.never) return false;
-	if (where.condition) compiler.andContext(where.condition, void 0, embeds);
-	return true;
-}
-/** Compiles an operation into a PostgREST plan. */
-function compilePostgrest(op) {
-	const compiler = new PostgrestCompiler();
-	const embeds = compiler.withPath([], void 0);
-	const selection = op.kind === "select" ? op.selection : op.kind === "insert" ? op.returning : op.returning;
-	if (selection) for (const include of selection.includes) compiler.include(include, void 0, embeds);
-	let matches = true;
-	if (op.kind === "select" || op.kind === "update" || op.kind === "delete") {
-		const before = embeds.length;
-		matches = applyWhere(compiler, op.where, embeds);
-		if (op.kind !== "select" && embeds.length > before) invalidRequest(`Relation filters are not supported in ${op.kind} on PostgREST; filter by key instead`, op.table.key);
-	}
-	let range;
-	if (op.kind === "select") {
-		for (const term of op.orderBy) compiler.order(term, void 0);
-		if (op.offset !== void 0) {
-			const from = op.offset;
-			range = {
-				from,
-				to: op.limit === void 0 ? Number.MAX_SAFE_INTEGER : from + op.limit - 1
-			};
-		} else if (op.limit !== void 0) compiler.limits.push({
-			count: op.limit,
-			referencedTable: void 0
-		});
-	}
-	return {
-		select: selection ? renderSelect(selection, embeds) : void 0,
-		filters: compiler.filters,
-		orders: compiler.orders,
-		limits: compiler.limits,
-		range,
-		never: !matches
-	};
-}
-//#endregion
-//#region src/core/postgrest-executor.ts
-function scope(client, schema) {
-	const loose = client;
-	if (schema === "public" || !loose.schema) return loose;
-	let schemas = scopedClients.get(client);
-	if (!schemas) {
-		schemas = /* @__PURE__ */ new Map();
-		scopedClients.set(client, schemas);
-	}
-	let scoped = schemas.get(schema);
-	if (!scoped) {
-		scoped = loose.schema(schema);
-		schemas.set(schema, scoped);
-	}
-	return scoped;
-}
-/** `schema()` builds a new client on every call; one per client and schema is enough. */
-const scopedClients = /* @__PURE__ */ new WeakMap();
-function fromTable(client, schema, table) {
-	return scope(client, schema).from(table);
-}
-/** A POST to the function: arguments such as query vectors are too long for a URL. */
-function fromFunction(client, source, options) {
-	const scoped = scope(client, source.schema);
-	if (!scoped.rpc) throw new TypeError(`better-supabase: the client has no rpc(), needed to read from ${source.name}`);
-	return scoped.rpc(source.name, source.args, options);
-}
-function applyFilters(builder, plan) {
-	let query = builder;
-	for (const filter of plan.filters) query = filter.kind === "filter" ? query.filter(filter.path, filter.operator, filter.value) : query.or(filter.expression, filter.referencedTable ? { referencedTable: filter.referencedTable } : {});
-	return query;
-}
-function applyOrderAndLimits(builder, plan) {
-	let query = builder;
-	for (const order of plan.orders) {
-		const options = { ascending: order.ascending };
-		if (order.nullsFirst !== void 0) options.nullsFirst = order.nullsFirst;
-		if (order.referencedTable) options.referencedTable = order.referencedTable;
-		query = query.order(order.column, options);
-	}
-	for (const limit of plan.limits) query = query.limit(limit.count, limit.referencedTable ? { referencedTable: limit.referencedTable } : {});
-	if (plan.range) query = query.range(plan.range.from, plan.range.to);
-	return query;
-}
-function build(client, op, plan) {
-	const base = fromTable(client, op.table.schema, op.table.name);
-	switch (op.kind) {
-		case "select": {
-			const options = {};
-			if (op.count) options.count = op.count;
-			if (op.head) options.head = true;
-			let query = applyOrderAndLimits(applyFilters(op.source ? fromFunction(client, op.source, options).select(plan.select) : base.select(plan.select, options), plan), plan);
-			if (op.single === "one") query = query.single();
-			if (op.single === "maybe") query = query.maybeSingle();
-			return query;
-		}
-		case "insert": {
-			const rows = op.rows.length === 1 ? op.rows[0] : op.rows;
-			const count = plan.select === void 0 ? { count: "exact" } : {};
-			let query = op.onConflict ? base.upsert(rows, {
-				onConflict: op.onConflict.columns.join(","),
-				ignoreDuplicates: op.onConflict.action === "ignore",
-				defaultToNull: op.defaultToNull,
-				...count
-			}) : base.insert(rows, {
-				defaultToNull: op.defaultToNull,
-				...count
-			});
-			if (plan.select !== void 0) query = query.select(plan.select);
-			return query;
-		}
-		case "update": {
-			const count = plan.select === void 0 ? { count: "exact" } : {};
-			let query = applyFilters(base.update(op.set, count), plan);
-			if (plan.select !== void 0) query = query.select(plan.select);
-			return query;
-		}
-		case "delete": {
-			const count = plan.select === void 0 ? { count: "exact" } : {};
-			let query = applyFilters(base.delete(count), plan);
-			if (plan.select !== void 0) query = query.select(plan.select);
-			return query;
-		}
-		default: return op;
-	}
-}
-function rowsOf(data) {
-	if (data === null || data === void 0) return [];
-	if (Array.isArray(data)) return data;
-	return [data];
-}
-/** Executes IR operations through a supabase-js client. */
-const aborted = () => dbError("aborted", "The request was aborted");
-function postgrestExecutor(client) {
-	return {
-		name: "postgrest",
-		functionSources: true,
-		async execute(op, context) {
-			let plan;
-			try {
-				plan = compilePostgrest(op);
-			} catch (cause) {
-				return err(toDbError(cause));
-			}
-			if (plan.never) return ok({
-				rows: [],
-				count: 0
-			});
-			if (context.signal?.aborted) return err(aborted());
-			let query = build(client, op, plan);
-			if (context.signal) query = query.abortSignal(context.signal);
-			const response = await query;
-			if (response.error) {
-				if (context.signal?.aborted) return err(aborted());
-				return err(mapDbError(response.error, context.errorMappers));
-			}
-			return ok({
-				rows: rowsOf(response.data),
-				count: response.count ?? null
-			});
-		},
-		async rpc(name, args, context) {
-			const scoped = scope(client, context.schema);
-			if (!scoped.rpc) return err(toDbError(/* @__PURE__ */ new Error("The client does not support rpc()")));
-			if (context.signal?.aborted) return err(aborted());
-			let query = context.get ? scoped.rpc(name, queryArgs(args), { get: true }) : scoped.rpc(name, args);
-			if (context.signal) query = query.abortSignal(context.signal);
-			const response = await query;
-			if (response.error) {
-				if (context.signal?.aborted) return err(aborted());
-				return err(mapDbError(response.error, context.errorMappers));
-			}
-			return ok(response.data);
-		}
-	};
-}
-/**
-* GET arguments travel in the query string, where supabase-js would print an
-* object as `[object Object]`; json and jsonb parameters take it as JSON.
-*/
-function queryArgs(args) {
-	return Object.fromEntries(Object.entries(args).map(([key, value]) => [key, typeof value === "object" && value !== null && !Array.isArray(value) ? JSON.stringify(value) : value]));
-}
-/** The compiled plan for an operation; useful for debugging and tests. */
-function explainPostgrest(op) {
-	return compilePostgrest(op);
-}
-//#endregion
-//#region src/core/stats.ts
-const EMPTY_STATS = {
-	calls: 0,
-	waves: 0,
-	tables: [],
-	ms: 0
-};
-/**
-* Counts calls and waves. A recorder with a `parent` also reports to it, so
-* a request-wide recorder sees every scope's calls.
-*/
-var StatsRecorder = class {
-	#parent;
-	#now;
-	#tables = /* @__PURE__ */ new Set();
-	#calls = 0;
-	#waves = 0;
-	#inFlight = 0;
-	#first;
-	#last;
-	constructor(parent, now = () => performance.now()) {
-		this.#parent = parent;
-		this.#now = now;
-	}
-	/** Records a call to `table`; the returned function ends it. */
-	begin(table) {
-		const end = this.#parent?.begin(table);
-		const started = this.#now();
-		if (this.#inFlight === 0) this.#waves += 1;
-		this.#inFlight += 1;
-		this.#calls += 1;
-		this.#tables.add(table);
-		this.#first ??= started;
-		let ended = false;
-		return () => {
-			if (ended) return;
-			ended = true;
-			this.#inFlight -= 1;
-			this.#last = Math.max(this.#last ?? 0, this.#now());
-			end?.();
-		};
-	}
-	/** The totals so far. */
-	snapshot() {
-		return {
-			calls: this.#calls,
-			waves: this.#waves,
-			tables: [...this.#tables],
-			ms: this.#first === void 0 || this.#last === void 0 ? 0 : Math.round((this.#last - this.#first) * 100) / 100
-		};
-	}
-};
-/** Wraps an executor so every call is recorded. */
-function recordStats(executor, recorder) {
-	const wrapped = {
-		name: executor.name,
-		async execute(op, context) {
-			const end = recorder.begin(op.table.key);
-			try {
-				return await executor.execute(op, context);
-			} finally {
-				end();
-			}
-		}
-	};
-	if (executor.rpc) {
-		const rpc = executor.rpc.bind(executor);
-		return {
-			...wrapped,
-			async rpc(name, args, context) {
-				const end = recorder.begin(`${name}()`);
-				try {
-					return await rpc(name, args, context);
-				} finally {
-					end();
-				}
-			}
-		};
-	}
-	return wrapped;
-}
-//#endregion
-export { postgrestExecutor as a, explainPostgrest as i, StatsRecorder as n, compilePostgrest as o, recordStats as r, EMPTY_STATS as t };

package/dist/support-DT-OhSxD.d.ts

@@ -1,88 +0,0 @@
-/// <reference lib="esnext.temporal" />
-import { t as BetterPostgres } from "./pool-C9voM4Kw.js";
-//#region src/auth/support.d.ts
-type SupportEndedBy = "admin" | "expired" | "revoked";
-/** A support session: a platform admin viewing the app as `targetUserId`. */
-interface SupportSession {
-  readonly id: string;
-  readonly adminId: string;
-  readonly targetUserId: string;
-  readonly reason: string;
-  /** Writes fail while it is true (`begin read only`). */
-  readonly readOnly: boolean;
-  readonly tenant?: string;
-  readonly startedAt: Temporal.Instant;
-  readonly expiresAt: Temporal.Instant;
-  readonly endedAt?: Temporal.Instant;
-  readonly endedBy?: SupportEndedBy;
-  /** App data, such as a ticket id. */
-  readonly metadata: Readonly<Record<string, unknown>>;
-}
-interface SupportStartInput {
-  readonly adminId: string;
-  /**
-   * The admin's verified claims. The SQL store runs `start_support_session`
-   * with them, so `is_platform()` checks the admin in the database too.
-   */
-  readonly adminClaims: Readonly<Record<string, unknown>>;
-  readonly targetUserId: string;
-  readonly reason: string;
-  readonly ttlSeconds: number;
-  readonly readOnly: boolean;
-  readonly tenant?: string;
-  readonly metadata: Readonly<Record<string, unknown>>;
-}
-/** A caller's verified claims, which the store runs a call with. */
-type SupportCallerClaims = Readonly<Record<string, unknown>>;
-interface SupportListFilter {
-  readonly adminId?: string;
-  readonly targetUserId?: string;
-  /** `true`: running sessions only; `false`: ended or expired ones only. */
-  readonly active?: boolean;
-  /** Defaults to 50. */
-  readonly limit?: number;
-}
-/**
- * Where support sessions live. `sqlSupportStore` uses the `support-sessions`
- * SQL kit module; implement this for another store and check it with
- * `testSupportSessionStore` from `better-supabase/testing`.
- */
-interface SupportSessionStore {
-  readonly apiVersion: 1;
-  readonly name: string;
-  /** Starts a session and ends the admin's previous one. Rejects when the store refuses. */
-  start(input: SupportStartInput): Promise<SupportSession>;
-  /**
-   * The admin's session while it is running; `undefined` once ended or
-   * expired. With the admin's `claims`, the store also checks that the admin
-   * may still start sessions.
-   */
-  get(sessionId: string, adminId: string, claims?: SupportCallerClaims): Promise<SupportSession | undefined>;
-  /**
-   * `false` when it was not running. With `claims`, it runs as that caller:
-   * the session's admin, or staff with the revoke permission.
-   */
-  end(sessionId: string, endedBy: SupportEndedBy, claims?: SupportCallerClaims): Promise<boolean>;
-  /** With `claims`, only what that caller may view. */
-  list(filter?: SupportListFilter, claims?: SupportCallerClaims): Promise<readonly SupportSession[]>;
-  /** The claims `targetUserId` would get, when the store can build them. */
-  claims?(targetUserId: string): Promise<Readonly<Record<string, unknown>>>;
-}
-interface SqlSupportStoreOptions {
-  /** `kits.support-sessions.schema`. Defaults to `better_supabase`. */
-  readonly schema?: string;
-}
-/**
- * Support sessions in the `support-sessions` SQL kit module. `start` runs
- * as the admin, so the module's `is_platform()` gate applies; the reads run
- * on the admin connection.
- */
-declare function sqlSupportStore(postgres: Pick<BetterPostgres, "admin" | "asUser">, options?: SqlSupportStoreOptions): SupportSessionStore;
-/**
- * The claims a support session runs with: the target's, plus `act` naming
- * the admin, the reason and the session (the audit module records all three).
- * `role` falls back to `authenticated`; the admin's claims never leak in.
- */
-declare function supportClaims(session: Pick<SupportSession, "id" | "adminId" | "targetUserId" | "reason" | "readOnly">, target: Readonly<Record<string, unknown>>): Record<string, unknown>;
-//#endregion
-export { SupportSession as a, sqlSupportStore as c, SupportListFilter as i, supportClaims as l, SupportCallerClaims as n, SupportSessionStore as o, SupportEndedBy as r, SupportStartInput as s, SqlSupportStoreOptions as t };

package/dist/template-mbvlysOo.d.ts

@@ -1,6 +0,0 @@
-//#region src/core/template.d.ts
-/** Placeholder names in a `{name}` template. */
-type TemplateParams<P extends string> = P extends `${string}{${infer K}}${infer R}` ? K | TemplateParams<R> : never;
-type TemplateValues<P extends string> = { readonly [K in TemplateParams<P>]: string | number; };
-//#endregion
-export { TemplateValues as n, TemplateParams as t };