@assemble-dev/shared-utils 0.1.0

package/dist/auth/index.js

@@ -0,0 +1,155 @@
+import {
+  AppError
+} from "../chunk-CP7QDN2K.js";
+
+// src/auth/create-auth-middleware.ts
+import { AppErrorCode as AppErrorCode2 } from "@assemble-dev/shared-types";
+
+// src/auth/verify-supabase-jwt.ts
+import { AppErrorCode } from "@assemble-dev/shared-types";
+import { createLocalJWKSet, createRemoteJWKSet, jwtVerify } from "jose";
+import { z } from "zod";
+var SUPABASE_AUTHENTICATED_AUDIENCE = "authenticated";
+var SupabaseJwtUserMetadataSchema = z.object({
+  name: z.string().optional(),
+  full_name: z.string().optional()
+});
+var SupabaseJwtClaimsSchema = z.object({
+  sub: z.string().min(1),
+  exp: z.number().int().positive(),
+  iss: z.string().min(1),
+  aud: z.union([z.string(), z.array(z.string())]),
+  email: z.string().email().optional(),
+  user_metadata: SupabaseJwtUserMetadataSchema.optional()
+});
+function createSupabaseRemoteKeySet(jwksUrl) {
+  return createRemoteJWKSet(new URL(jwksUrl));
+}
+function createSupabaseLocalKeySet(jwks) {
+  return createLocalJWKSet(jwks);
+}
+function createUnauthorizedError(message) {
+  return new AppError({
+    code: AppErrorCode.Unauthorized,
+    message,
+    statusCode: 401
+  });
+}
+async function verifySignedTokenPayload(input) {
+  try {
+    const verification = await jwtVerify(input.token, input.keySet, {
+      issuer: input.issuer,
+      audience: input.audience ?? SUPABASE_AUTHENTICATED_AUDIENCE,
+      algorithms: ["ES256", "RS256"],
+      currentDate: input.now === void 0 ? void 0 : new Date(input.now)
+    });
+    const parsedClaims = SupabaseJwtClaimsSchema.safeParse(verification.payload);
+    if (!parsedClaims.success) {
+      throw createUnauthorizedError("Invalid authentication token claims");
+    }
+    return parsedClaims.data;
+  } catch (error) {
+    if (error instanceof AppError) {
+      throw error;
+    }
+    throw createUnauthorizedError("Invalid authentication token");
+  }
+}
+function ensureAudienceIsAuthenticated(claims, expectedAudience) {
+  const audiences = Array.isArray(claims.aud) ? claims.aud : [claims.aud];
+  if (!audiences.includes(expectedAudience)) {
+    throw createUnauthorizedError("Authentication token audience is not trusted");
+  }
+}
+async function verifySupabaseJwt(input) {
+  const claims = await verifySignedTokenPayload(input);
+  ensureAudienceIsAuthenticated(
+    claims,
+    input.audience ?? SUPABASE_AUTHENTICATED_AUDIENCE
+  );
+  return claims;
+}
+
+// src/auth/create-auth-middleware.ts
+function createUnauthorizedError2(message) {
+  return new AppError({
+    code: AppErrorCode2.Unauthorized,
+    message,
+    statusCode: 401
+  });
+}
+function extractBearerToken(headerValue) {
+  if (headerValue === void 0) {
+    throw createUnauthorizedError2("Missing Authorization header");
+  }
+  const bearerPrefix = "Bearer ";
+  if (!headerValue.startsWith(bearerPrefix)) {
+    throw createUnauthorizedError2("Invalid Authorization header");
+  }
+  const token = headerValue.slice(bearerPrefix.length).trim();
+  if (token.length === 0) {
+    throw createUnauthorizedError2("Missing bearer token");
+  }
+  return token;
+}
+function buildAuthSubjectFromClaims(claims) {
+  if (claims.email === void 0) {
+    throw createUnauthorizedError2("Authentication token is missing an email");
+  }
+  return {
+    id: claims.sub,
+    email: claims.email,
+    name: claims.user_metadata?.name ?? claims.user_metadata?.full_name ?? null
+  };
+}
+function createAuthMiddleware(config) {
+  return async (c, next) => {
+    const token = extractBearerToken(c.req.header("authorization"));
+    const claims = await verifySupabaseJwt({
+      token,
+      keySet: config.keySet,
+      issuer: config.issuer,
+      audience: config.audience
+    });
+    const subject = buildAuthSubjectFromClaims(claims);
+    const user = await config.resolveAuthUser(subject);
+    c.set("auth", { userId: user.id, authSubjectId: claims.sub });
+    await next();
+  };
+}
+
+// src/auth/known-test-credentials.ts
+import { createHash } from "node:crypto";
+import { AppErrorCode as AppErrorCode3 } from "@assemble-dev/shared-types";
+var KNOWN_TEST_CREDENTIAL_FINGERPRINTS = [
+  "56e17db07a352344ec8f8d91b98d65ee78213181872b8a66e41087442bb33f5b",
+  "39377069fcfbfbe509b540b9005998930d1d847a86776b560998a5cf958ba4d6"
+];
+function computeCredentialFingerprint(value) {
+  return createHash("sha256").update(value.trim()).digest("hex");
+}
+function assertNotTestCredentialInProduction(input) {
+  if (input.nodeEnv !== "production") {
+    return;
+  }
+  const fingerprint = computeCredentialFingerprint(input.value);
+  if (KNOWN_TEST_CREDENTIAL_FINGERPRINTS.includes(fingerprint)) {
+    throw new AppError({
+      code: AppErrorCode3.InternalServerError,
+      message: `${input.label} is set to a committed test credential and must be replaced with a real production value`,
+      statusCode: 500,
+      details: { label: input.label }
+    });
+  }
+}
+export {
+  SUPABASE_AUTHENTICATED_AUDIENCE,
+  SupabaseJwtClaimsSchema,
+  assertNotTestCredentialInProduction,
+  buildAuthSubjectFromClaims,
+  computeCredentialFingerprint,
+  createAuthMiddleware,
+  createSupabaseLocalKeySet,
+  createSupabaseRemoteKeySet,
+  verifySupabaseJwt
+};

package/dist/chunk-7TK7K2QQ.js

@@ -0,0 +1,59 @@
+// src/ids/generate-id.ts
+import { randomBytes } from "node:crypto";
+var idPrefixes = [
+  "run_",
+  "evt_",
+  "key_",
+  "eval_",
+  "apr_"
+];
+var suffixByteLength = 16;
+var suffixHexLength = suffixByteLength * 2;
+var suffixPattern = /^[0-9a-f]+$/;
+function generateRandomSuffix() {
+  return randomBytes(suffixByteLength).toString("hex");
+}
+function generatePrefixedId(prefix) {
+  return `${prefix}${generateRandomSuffix()}`;
+}
+function generateRunId() {
+  return generatePrefixedId("run_");
+}
+function generateTraceEventId() {
+  return generatePrefixedId("evt_");
+}
+function generateApiKeyId() {
+  return generatePrefixedId("key_");
+}
+function generateEvalRunId() {
+  return generatePrefixedId("eval_");
+}
+function generateApprovalId() {
+  return generatePrefixedId("apr_");
+}
+function parseIdPrefix(id) {
+  const matchedPrefix = idPrefixes.find((prefix) => id.startsWith(prefix));
+  return matchedPrefix ?? null;
+}
+function hasIdPrefix(id, prefix) {
+  return id.startsWith(prefix);
+}
+function isValidPrefixedId(id, prefix) {
+  if (!id.startsWith(prefix)) {
+    return false;
+  }
+  const suffix = id.slice(prefix.length);
+  return suffix.length === suffixHexLength && suffixPattern.test(suffix);
+}
+
+export {
+  idPrefixes,
+  generateRunId,
+  generateTraceEventId,
+  generateApiKeyId,
+  generateEvalRunId,
+  generateApprovalId,
+  parseIdPrefix,
+  hasIdPrefix,
+  isValidPrefixedId
+};

package/dist/chunk-CP7QDN2K.js

@@ -0,0 +1,19 @@
+// src/errors/app-error.ts
+var AppError = class extends Error {
+  code;
+  statusCode;
+  details;
+  cause;
+  constructor(input) {
+    super(input.message);
+    this.name = "AppError";
+    this.code = input.code;
+    this.statusCode = input.statusCode;
+    this.details = input.details;
+    this.cause = input.cause;
+  }
+};
+
+export {
+  AppError
+};

package/dist/chunk-HOZLAE6A.js

@@ -0,0 +1,22 @@
+// src/errors/handle-app-error.ts
+function createAppErrorResponse(error) {
+  if (error.details === void 0) {
+    return {
+      error: {
+        code: error.code,
+        message: error.message
+      }
+    };
+  }
+  return {
+    error: {
+      code: error.code,
+      message: error.message,
+      details: error.details
+    }
+  };
+}
+
+export {
+  createAppErrorResponse
+};

package/dist/chunk-OW6VCN32.js

@@ -0,0 +1,17 @@
+// src/provider-keys/named-api-key-env.ts
+var providerApiKeyNamePattern = /^[A-Za-z][A-Za-z0-9_-]*$/;
+var expectedProviderApiKeyNameFormat = "a letter followed by letters, numbers, hyphens, or underscores";
+function validateProviderApiKeyName(apiKeyName) {
+  return providerApiKeyNamePattern.test(apiKeyName);
+}
+function buildNamedApiKeyEnvVarName(baseEnvVarName, apiKeyName) {
+  const normalizedName = apiKeyName.toUpperCase().replaceAll("-", "_");
+  return `${baseEnvVarName}_${normalizedName}`;
+}
+
+export {
+  providerApiKeyNamePattern,
+  expectedProviderApiKeyNameFormat,
+  validateProviderApiKeyName,
+  buildNamedApiKeyEnvVarName
+};

package/dist/chunk-XDYQIW3Q.js

@@ -0,0 +1,191 @@
+// src/redaction/redaction-mode.ts
+import { z } from "zod";
+var RedactionModeSchema = z.enum([
+  "metadata-only",
+  "redacted",
+  "full"
+]);
+var defaultRedactionMode = "redacted";
+function resolveRedactionMode(mode) {
+  return mode ?? defaultRedactionMode;
+}
+
+// src/redaction/secret-detection.ts
+var redactedValue = "[REDACTED]";
+var providerApiKeyPrefixes = [
+  "sk-",
+  "sk_live_",
+  "sk_test_",
+  "asm_",
+  "ghp_",
+  "gho_",
+  "ghs_",
+  "ghu_",
+  "github_pat_",
+  "xoxb-",
+  "xoxp-",
+  "xoxa-",
+  "xoxs-",
+  "pk_live_",
+  "rk_live_",
+  "whsec_",
+  "AKIA"
+];
+var secretBodyPattern = /^[A-Za-z0-9+/=_.-]{12,}$/;
+var bearerTokenPattern = /^bearer\s+\S+/i;
+var jwtShapedPattern = /^eyJ[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}/;
+var secretFieldNameSuffixes = [
+  "api_key",
+  "apikey",
+  "secret",
+  "token",
+  "password"
+];
+function escapeRegExpLiteral(literal) {
+  return literal.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function buildProviderApiKeySubstringPattern() {
+  const escapedPrefixes = providerApiKeyPrefixes.map(escapeRegExpLiteral).join("|");
+  return new RegExp(`(?:${escapedPrefixes})[A-Za-z0-9+/=_.-]{12,}`, "g");
+}
+var providerApiKeySubstringPattern = buildProviderApiKeySubstringPattern();
+var bearerTokenSubstringPattern = /bearer\s+\S+/gi;
+var jwtShapedSubstringPattern = /eyJ[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}[A-Za-z0-9_.-]*/g;
+function replaceProviderApiKeySubstrings(value) {
+  return value.replace(providerApiKeySubstringPattern, redactedValue);
+}
+function replaceSecretShapedSubstrings(value) {
+  return replaceProviderApiKeySubstrings(value).replace(bearerTokenSubstringPattern, redactedValue).replace(jwtShapedSubstringPattern, redactedValue);
+}
+function isProviderApiKeyShapedString(value) {
+  return providerApiKeyPrefixes.some(
+    (prefix) => value.startsWith(prefix) && secretBodyPattern.test(value.slice(prefix.length))
+  );
+}
+function isBearerTokenShapedString(value) {
+  return bearerTokenPattern.test(value);
+}
+function isJwtShapedString(value) {
+  return jwtShapedPattern.test(value);
+}
+function isSecretShapedString(value) {
+  return isProviderApiKeyShapedString(value) || isBearerTokenShapedString(value) || isJwtShapedString(value);
+}
+function isSecretNamedField(fieldName) {
+  const normalizedFieldName = fieldName.toLowerCase();
+  if (normalizedFieldName === "authorization") {
+    return true;
+  }
+  return secretFieldNameSuffixes.some(
+    (suffix) => normalizedFieldName.endsWith(suffix)
+  );
+}
+
+// src/redaction/summarize-json-value.ts
+function summarizeJsonValue(value) {
+  if (value === null) {
+    return { kind: "null" };
+  }
+  if (typeof value === "string") {
+    return { kind: "string", length: value.length };
+  }
+  if (typeof value === "number") {
+    return { kind: "number" };
+  }
+  if (typeof value === "boolean") {
+    return { kind: "boolean" };
+  }
+  if (Array.isArray(value)) {
+    return { kind: "array", length: value.length };
+  }
+  return { kind: "object", keys: Object.keys(value) };
+}
+
+// src/redaction/redact-trace-payload.ts
+import { z as z2 } from "zod";
+var RedactTracePayloadOptionsSchema = z2.object({
+  mode: RedactionModeSchema.optional(),
+  sensitiveFieldNames: z2.array(z2.string()).optional()
+});
+function redactTracePayload(payload, options) {
+  const mode = resolveRedactionMode(options?.mode);
+  if (mode === "metadata-only") {
+    return { payload: summarizeJsonValue(payload), redacted: true };
+  }
+  const context = {
+    mode,
+    sensitiveFieldNames: buildSensitiveFieldNameSet(
+      options?.sensitiveFieldNames
+    ),
+    redactedValueCount: 0
+  };
+  const redactedPayload = redactJsonValue(payload, context);
+  return {
+    payload: redactedPayload,
+    redacted: mode !== "full" || context.redactedValueCount > 0
+  };
+}
+function buildSensitiveFieldNameSet(fieldNames) {
+  return new Set(
+    (fieldNames ?? []).map((fieldName) => fieldName.toLowerCase())
+  );
+}
+function redactJsonValue(value, context) {
+  if (typeof value === "string") {
+    return redactStringValue(value, context);
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => redactJsonValue(item, context));
+  }
+  if (value !== null && typeof value === "object") {
+    return redactObjectValue(value, context);
+  }
+  return value;
+}
+function redactStringValue(value, context) {
+  const shouldRedactWholeString = context.mode === "full" ? isProviderApiKeyShapedString(value) : isSecretShapedString(value);
+  if (shouldRedactWholeString) {
+    context.redactedValueCount += 1;
+    return redactedValue;
+  }
+  const valueWithSecretsReplaced = context.mode === "full" ? replaceProviderApiKeySubstrings(value) : replaceSecretShapedSubstrings(value);
+  if (valueWithSecretsReplaced !== value) {
+    context.redactedValueCount += 1;
+  }
+  return valueWithSecretsReplaced;
+}
+function redactObjectValue(value, context) {
+  const redactedEntries = Object.entries(value).map(
+    ([fieldName, fieldValue]) => {
+      if (shouldRedactFieldValue(fieldName, context)) {
+        context.redactedValueCount += 1;
+        return [fieldName, redactedValue];
+      }
+      return [fieldName, redactJsonValue(fieldValue, context)];
+    }
+  );
+  return Object.fromEntries(redactedEntries);
+}
+function shouldRedactFieldValue(fieldName, context) {
+  if (context.sensitiveFieldNames.has(fieldName.toLowerCase())) {
+    return true;
+  }
+  return context.mode === "redacted" && isSecretNamedField(fieldName);
+}
+
+export {
+  RedactionModeSchema,
+  defaultRedactionMode,
+  resolveRedactionMode,
+  redactedValue,
+  replaceProviderApiKeySubstrings,
+  replaceSecretShapedSubstrings,
+  isProviderApiKeyShapedString,
+  isBearerTokenShapedString,
+  isJwtShapedString,
+  isSecretShapedString,
+  isSecretNamedField,
+  summarizeJsonValue,
+  RedactTracePayloadOptionsSchema,
+  redactTracePayload
+};

package/dist/errors/index.cjs

@@ -0,0 +1,66 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/errors/index.ts
+var errors_exports = {};
+__export(errors_exports, {
+  AppError: () => AppError,
+  createAppErrorResponse: () => createAppErrorResponse
+});
+module.exports = __toCommonJS(errors_exports);
+
+// src/errors/app-error.ts
+var AppError = class extends Error {
+  code;
+  statusCode;
+  details;
+  cause;
+  constructor(input) {
+    super(input.message);
+    this.name = "AppError";
+    this.code = input.code;
+    this.statusCode = input.statusCode;
+    this.details = input.details;
+    this.cause = input.cause;
+  }
+};
+
+// src/errors/handle-app-error.ts
+function createAppErrorResponse(error) {
+  if (error.details === void 0) {
+    return {
+      error: {
+        code: error.code,
+        message: error.message
+      }
+    };
+  }
+  return {
+    error: {
+      code: error.code,
+      message: error.message,
+      details: error.details
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AppError,
+  createAppErrorResponse
+});

package/dist/errors/index.d.cts

@@ -0,0 +1,6 @@
+import { A as AppError } from '../app-error-D7pnDUHg.cjs';
+import { AppErrorResponse } from '@assemble-dev/shared-types';
+
+declare function createAppErrorResponse(error: AppError): AppErrorResponse;
+
+export { AppError, createAppErrorResponse };

package/dist/errors/index.d.ts

@@ -0,0 +1,6 @@
+import { A as AppError } from '../app-error-D7pnDUHg.js';
+import { AppErrorResponse } from '@assemble-dev/shared-types';
+
+declare function createAppErrorResponse(error: AppError): AppErrorResponse;
+
+export { AppError, createAppErrorResponse };

package/dist/errors/index.js

@@ -0,0 +1,10 @@
+import {
+  createAppErrorResponse
+} from "../chunk-HOZLAE6A.js";
+import {
+  AppError
+} from "../chunk-CP7QDN2K.js";
+export {
+  AppError,
+  createAppErrorResponse
+};

package/dist/ids/index.cjs

@@ -0,0 +1,93 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/ids/index.ts
+var ids_exports = {};
+__export(ids_exports, {
+  generateApiKeyId: () => generateApiKeyId,
+  generateApprovalId: () => generateApprovalId,
+  generateEvalRunId: () => generateEvalRunId,
+  generateRunId: () => generateRunId,
+  generateTraceEventId: () => generateTraceEventId,
+  hasIdPrefix: () => hasIdPrefix,
+  idPrefixes: () => idPrefixes,
+  isValidPrefixedId: () => isValidPrefixedId,
+  parseIdPrefix: () => parseIdPrefix
+});
+module.exports = __toCommonJS(ids_exports);
+
+// src/ids/generate-id.ts
+var import_node_crypto = require("node:crypto");
+var idPrefixes = [
+  "run_",
+  "evt_",
+  "key_",
+  "eval_",
+  "apr_"
+];
+var suffixByteLength = 16;
+var suffixHexLength = suffixByteLength * 2;
+var suffixPattern = /^[0-9a-f]+$/;
+function generateRandomSuffix() {
+  return (0, import_node_crypto.randomBytes)(suffixByteLength).toString("hex");
+}
+function generatePrefixedId(prefix) {
+  return `${prefix}${generateRandomSuffix()}`;
+}
+function generateRunId() {
+  return generatePrefixedId("run_");
+}
+function generateTraceEventId() {
+  return generatePrefixedId("evt_");
+}
+function generateApiKeyId() {
+  return generatePrefixedId("key_");
+}
+function generateEvalRunId() {
+  return generatePrefixedId("eval_");
+}
+function generateApprovalId() {
+  return generatePrefixedId("apr_");
+}
+function parseIdPrefix(id) {
+  const matchedPrefix = idPrefixes.find((prefix) => id.startsWith(prefix));
+  return matchedPrefix ?? null;
+}
+function hasIdPrefix(id, prefix) {
+  return id.startsWith(prefix);
+}
+function isValidPrefixedId(id, prefix) {
+  if (!id.startsWith(prefix)) {
+    return false;
+  }
+  const suffix = id.slice(prefix.length);
+  return suffix.length === suffixHexLength && suffixPattern.test(suffix);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  generateApiKeyId,
+  generateApprovalId,
+  generateEvalRunId,
+  generateRunId,
+  generateTraceEventId,
+  hasIdPrefix,
+  idPrefixes,
+  isValidPrefixedId,
+  parseIdPrefix
+});

package/dist/ids/index.d.cts

@@ -0,0 +1,13 @@
+type IdPrefix = "run_" | "evt_" | "key_" | "eval_" | "apr_";
+type PrefixedId<TPrefix extends IdPrefix> = `${TPrefix}${string}`;
+declare const idPrefixes: readonly IdPrefix[];
+declare function generateRunId(): PrefixedId<"run_">;
+declare function generateTraceEventId(): PrefixedId<"evt_">;
+declare function generateApiKeyId(): PrefixedId<"key_">;
+declare function generateEvalRunId(): PrefixedId<"eval_">;
+declare function generateApprovalId(): PrefixedId<"apr_">;
+declare function parseIdPrefix(id: string): IdPrefix | null;
+declare function hasIdPrefix<TPrefix extends IdPrefix>(id: string, prefix: TPrefix): id is PrefixedId<TPrefix>;
+declare function isValidPrefixedId<TPrefix extends IdPrefix>(id: string, prefix: TPrefix): id is PrefixedId<TPrefix>;
+
+export { type IdPrefix, type PrefixedId, generateApiKeyId, generateApprovalId, generateEvalRunId, generateRunId, generateTraceEventId, hasIdPrefix, idPrefixes, isValidPrefixedId, parseIdPrefix };

package/dist/ids/index.d.ts

@@ -0,0 +1,13 @@
+type IdPrefix = "run_" | "evt_" | "key_" | "eval_" | "apr_";
+type PrefixedId<TPrefix extends IdPrefix> = `${TPrefix}${string}`;
+declare const idPrefixes: readonly IdPrefix[];
+declare function generateRunId(): PrefixedId<"run_">;
+declare function generateTraceEventId(): PrefixedId<"evt_">;
+declare function generateApiKeyId(): PrefixedId<"key_">;
+declare function generateEvalRunId(): PrefixedId<"eval_">;
+declare function generateApprovalId(): PrefixedId<"apr_">;
+declare function parseIdPrefix(id: string): IdPrefix | null;
+declare function hasIdPrefix<TPrefix extends IdPrefix>(id: string, prefix: TPrefix): id is PrefixedId<TPrefix>;
+declare function isValidPrefixedId<TPrefix extends IdPrefix>(id: string, prefix: TPrefix): id is PrefixedId<TPrefix>;
+
+export { type IdPrefix, type PrefixedId, generateApiKeyId, generateApprovalId, generateEvalRunId, generateRunId, generateTraceEventId, hasIdPrefix, idPrefixes, isValidPrefixedId, parseIdPrefix };