@pipeline-builder/api-core 4.1.6 → 4.1.8

package/lib/testing/mock-drizzle.js

@@ -0,0 +1,57 @@
+// Copyright 2026 Pipeline Builder Contributors
+// SPDX-License-Identifier: Apache-2.0
+/**
+ * Shared `drizzle-orm` module mock for ESM suites.
+ *
+ * WHY: eighteen suites hand-wrote `jest.unstable_mockModule('drizzle-orm', () => ({ … }))`
+ * with whatever operator subset they happened to need. `unstable_mockModule`
+ * replaces the WHOLE namespace, so the moment production code reached for an
+ * operator a suite had not listed (`desc` was present in 6 of the 18, absent in
+ * 12) ESM linking failed with "does not provide an export named X" — a build
+ * break with no relationship to the change that triggered it.
+ *
+ * THE FIX: start from the REAL module and overlay only what a suite asserts on.
+ * A new drizzle export — or a new operator used by production code — is inherited
+ * automatically, so the drift class is gone rather than merely re-synchronised.
+ *
+ * WHY IT LIVES IN api-core: every service already deep-imports test fixtures from
+ * `@pipeline-builder/api-core/lib/testing/*` (see tier-mock.ts). The deep path is
+ * NOT intercepted by a suite's `@pipeline-builder/api-core` module mock, so the
+ * factory is safe to import from inside a suite that mocks the api-core barrel.
+ *
+ * USAGE:
+ *   import { drizzleMock } from '@pipeline-builder/api-core/lib/testing/mock-drizzle.js';
+ *   jest.unstable_mockModule('drizzle-orm', () => drizzleMock({
+ *     eq: (col: unknown, val: unknown) => ({ _kind: 'eq', col, val }),
+ *   }));
+ *
+ * The eslint `no-restricted-syntax` rule added in `.projenrc.ts` fails any suite
+ * that goes back to an inline object literal here.
+ */
+import { jest } from '@jest/globals';
+/**
+ * The REAL drizzle-orm namespace, resolved LAZILY (and memoised) — evaluating it
+ * at module load races the ESM loader when a suite's static import graph already
+ * has drizzle in flight. `requireActual` bypasses the module mock, so this is
+ * safe to call from inside the very factory that replaces it.
+ */
+let actualDrizzleCache;
+try {
+    actualDrizzleCache = jest.requireActual('drizzle-orm');
+}
+catch {
+    actualDrizzleCache = undefined;
+}
+function actualDrizzle() {
+    actualDrizzleCache ??= jest.requireActual('drizzle-orm');
+    return actualDrizzleCache;
+}
+/**
+ * Build a `drizzle-orm` mock namespace: every real export, with `overrides`
+ * spread last so a suite can swap an operator for an inspectable stub (or a
+ * `jest.fn()` it asserts on) without having to enumerate the rest.
+ */
+export function drizzleMock(overrides = {}) {
+    return { ...actualDrizzle(), ...overrides };
+}
+//# sourceMappingURL=data:application/json;base64,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

package/lib/types/common.d.ts

@@ -222,6 +222,16 @@ export interface JwtPayload {
      * UI copy and audit rather than for a second enforcement point.
      */
     mfaRequired?: boolean;
+    /**
+     * The active org's "administrative actions require MFA" policy
+     * (`adminActionsRequireMfa`, strictest across the org and its ancestors).
+     * Present — and always `2` — only when the policy is on. It is resolved when
+     * the token is ISSUED, so services that can't read the org document still know
+     * the policy: `requireOrgAdminAssurance` refuses an `aal: 1` session on an
+     * administrative route when this claim is present. Changing the policy bumps
+     * every affected member's `tokenVersion`, so the claim can't go stale.
+     */
+    org_admin_aal?: 2;
     /**
      * BOOTSTRAP-ADMIN EXCEPTION (#8, revision 4). Set only on a session opened by
      * the install's bootstrap admin (`BOOTSTRAP_SUPERADMIN_EMAILS`, system org)
@@ -263,6 +273,16 @@ export interface JwtPayload {
      * a scoped token is minted with minimal role for least-privilege.
      */
     scope?: TokenScope;
+    /**
+     * The token's `permissions` were NARROWED to a catalog subset chosen when the
+     * credential was created (a permission-scoped personal access key or machine
+     * token). The claim is the record that `permissions` is the INTERSECTION of
+     * that subset with the holder's current Roles — not their full authority — so
+     * anything the token mints can only be narrower still, and it never carries
+     * `isSuperAdmin` or an admin `role` (both would bypass the subset). Only ever
+     * `true`; absent on unrestricted tokens.
+     */
+    permissionsRestricted?: boolean;
     /** Active organization ID (from UserOrganization membership) */
     organizationId?: string;
     /** Active organization name */

package/lib/types/common.js

@@ -48,4 +48,4 @@ export function isValidQuotaType(value) {
 export function effectiveRootOrgId(payload) {
     return payload.rootOrganizationId ?? payload.organizationId;
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"common.js","sourceRoot":"","sources":["../../src/types/common.ts"],"names":[],"mappings":"AAAA,+CAA+C;AAC/C,sCAAsC;AA2BtC;;;;GAIG;AACH,MAAM,CAAC,MAAM,YAAY,GAA0B,CAAC,kBAAkB,EAAE,eAAe,EAAE,MAAM,CAAC,CAAC;AAiDjG,kFAAkF;AAClF,MAAM,CAAC,MAAM,eAAe,GAA6B,CAAC,MAAM,EAAE,iBAAiB,EAAE,SAAS,CAAC,CAAC;AAChG,MAAM,CAAC,MAAM,UAAU,GAAwB,CAAC,QAAQ,EAAE,SAAS,CAAC,CAAC;AACrE,MAAM,CAAC,MAAM,YAAY,GAA0B,CAAC,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,UAAU,EAAE,QAAQ,EAAE,KAAK,CAAC,CAAC;AA8BxG;;GAEG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAG;IAC/B,SAAS,EAAE,WAAW,EAAE,UAAU,EAAE,SAAS,EAAE,cAAc;IAC7D,YAAY,EAAE,YAAY,EAAE,mBAAmB,EAAE,YAAY;CACrD,CAAC;AAEX;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,gBAAgB,CAAC,KAAc;IAC7C,OAAO,OAAO,KAAK,KAAK,QAAQ,IAAI,iBAAiB,CAAC,QAAQ,CAAC,KAAkB,CAAC,CAAC;AACrF,CAAC;AAkND;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,kBAAkB,CAChC,OAAkE;IAElE,OAAO,OAAO,CAAC,kBAAkB,IAAI,OAAO,CAAC,cAAc,CAAC;AAC9D,CAAC","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport type { Permission } from './permissions.js';\nimport type { QuotaTier } from './quota-tiers.js';\n\n/**\n * Capability scope catalog for machine/automation tokens. A scoped token carries\n * exactly one of these instead of role-based permissions; endpoints that accept a\n * scoped identity check it via `hasScope`. Kept a closed union (mirroring\n * {@link Permission}) so a typo on either the mint or the check side is a compile\n * error. Add a value here when introducing a new scoped-token surface.\n *\n * - `reporting:ingest` — the AWS event-ingestion Lambda's writes (`/reports/events`,\n *   `/reports/ingest-health`) and the incident webhook.\n * - `registry:push`    — `docker push` into the owning org's own namespace via\n *   image-registry's `/token` endpoint. Grants the raw-image write that\n *   `plugins:write` grants a person, and nothing else: a scoped token carries no\n *   permissions, so it can neither read the API nor push outside its org.\n * - `scim`             — an identity provider's SCIM 2.0 client (3b) driving\n *   `/scim/v2/Users` and `/scim/v2/Groups` for the key's OWN org. It provisions\n *   and deactivates memberships and moves people between directory groups; it\n *   can never read or write anything else, and — because a scoped token carries\n *   no permissions — it cannot author the group → Role rules its syncs resolve\n *   through. Only a service-account key may carry it; a person's token never does.\n */\nexport type TokenScope = 'reporting:ingest' | 'registry:push' | 'scim';\n\n/**\n * Runtime catalog of {@link TokenScope} (a union is erased at runtime). This is\n * the ONE allowlist every mint path validates against — platform's key/token\n * issue routes included — so a new scope is added in exactly one place.\n */\nexport const TOKEN_SCOPES: readonly TokenScope[] = ['reporting:ingest', 'registry:push', 'scim'];\n\n/**\n * What kind of principal a token speaks for. Auth decisions branch on this claim\n * — never on the shape of `sub` or on which optional claims happen to be present.\n *\n * - `user`            — a person (session, machine session, PAT or impersonation).\n * - `service_account` — a non-human account owned by ONE org, holding org Roles\n *                       and authenticating with a `pb_sa_…` key exchanged at\n *                       platform. Never satisfies an assurance/step-up gate.\n * - `service`         — an internal Pipeline Builder service ({@link signServiceToken}).\n */\nexport type PrincipalType = 'user' | 'service_account' | 'service';\n\n/**\n * How a token is used. `access` is a session-style access token (interactive,\n * machine-session or service); `api_key` is a standalone credential tracked by\n * its own record — a Personal Access Token or a service-account key, named by\n * `jti`.\n */\nexport type TokenUse = 'access' | 'api_key';\n\n/**\n * Authentication methods (`amr`, RFC 8176 style) that established a user's\n * session. `pwd` password sign-in; `oauth` social sign-in (Google, GitHub …);\n * `sso` per-org OIDC single sign-on; `webauthn` a passkey (WebAuthn assertion\n * with user verification); `stepup` a step-up re-verification token; `mfa` a\n * second factor was presented as well — today an authenticator-app code (TOTP)\n * or one of its recovery codes, so it appears ALONGSIDE the method that\n * identified the user (`['pwd', 'mfa']`), never on its own.\n */\nexport type AuthMethod = 'pwd' | 'oauth' | 'sso' | 'webauthn' | 'stepup' | 'mfa';\n\n/**\n * Authenticator assurance level of the session a token speaks for (#8).\n *\n * - `1` — one factor: a password, a social sign-in, or SSO through an IdP the\n *   org has NOT marked as enforcing MFA.\n * - `2` — MFA-grade: a passkey asserted with user verification, a password plus\n *   an authenticator-app code, or SSO through an IdP the org HAS marked as\n *   enforcing MFA (providers don't send `amr` reliably, so the org's own\n *   statement about its IdP is the signal).\n *\n * Fixed when the session is opened and stored on its refresh-session slot, so\n * refresh / renewal / switch-org copy it verbatim and can never RAISE it —\n * earning aal 2 always means authenticating again with a second factor.\n */\nexport type AssuranceLevel = 1 | 2;\n\n/** Runtime catalogs for the claim unions above (a union is erased at runtime). */\nexport const PRINCIPAL_TYPES: readonly PrincipalType[] = ['user', 'service_account', 'service'];\nexport const TOKEN_USES: readonly TokenUse[] = ['access', 'api_key'];\nexport const AUTH_METHODS: readonly AuthMethod[] = ['pwd', 'oauth', 'sso', 'webauthn', 'stepup', 'mfa'];\n\n/**\n * Quota type identifiers.\n *\n * - `plugins` / `pipelines` — count of created entities\n * - `apiCalls` — generic API call count (read-heavy paths)\n * - `aiCalls` — AI provider invocations (counted separately because each call\n *   has external dollar cost; sized smaller than apiCalls per tier)\n * - `storageBytes` — registry storage budget per org. Unlike the others\n *   (which count discrete events), this is a measured total recomputed\n *   on demand. Incremented by the image-registry's push-gate before\n *   issuing a token whose scope includes `push`; the GC scheduler\n *   eventually frees the bytes, then the next push-gate check reads\n *   the lower value. NOT a counter-style quota in the sense of\n *   `incrementUsage` — the registry pushes the measured total via\n *   `updateLimits`/`resetUsage` flows. Tier limits are bytes.\n * - `dashboards` / `alertRules` / `alertDestinations` / `idpConfigs` —\n *   resource-count quotas added to close per-org DoS surfaces in the\n *   user-editable feature tables. Without these caps a single org could\n *   spam thousands of dashboards / rules and bloat the shared Postgres /\n *   Mongo working sets. Counted at create time; decremented on delete.\n */\n// NOTE: `seats` is intentionally NOT here. It's a tier limit (QuotaTierLimits)\n// enforced by comparing the org's LIVE member count at invite time — not an\n// incrementing per-period counter like the consumable quotas below.\nexport type QuotaType =\n  | 'plugins' | 'pipelines' | 'apiCalls' | 'aiCalls' | 'storageBytes'\n  | 'dashboards' | 'alertRules' | 'alertDestinations' | 'idpConfigs';\n\n/**\n * Valid quota type values.\n */\nexport const VALID_QUOTA_TYPES = [\n  'plugins', 'pipelines', 'apiCalls', 'aiCalls', 'storageBytes',\n  'dashboards', 'alertRules', 'alertDestinations', 'idpConfigs',\n] as const;\n\n/**\n * Type guard to check if a value is a valid QuotaType.\n *\n * @param value - Value to check\n * @returns True if value is a valid QuotaType\n *\n * @example\n * ```typescript\n * if (isValidQuotaType(req.body.quotaType)) {\n *   // quotaType is guaranteed to be QuotaType\n * }\n * ```\n */\nexport function isValidQuotaType(value: unknown): value is QuotaType {\n  return typeof value === 'string' && VALID_QUOTA_TYPES.includes(value as QuotaType);\n}\n\n/**\n * Result from quota check operation.\n */\nexport interface QuotaCheckResult {\n  /** Whether the request is allowed */\n  allowed: boolean;\n  /** Maximum quota limit (-1 for unlimited) */\n  limit: number;\n  /** Current usage count */\n  used: number;\n  /** Remaining quota (-1 for unlimited) */\n  remaining: number;\n  /** ISO timestamp when quota resets */\n  resetAt: string;\n  /** Whether quota is unlimited */\n  unlimited: boolean;\n  /**\n   * True ONLY when this result is the fail-open sentinel returned because the\n   * quota service was unreachable / returned non-ok (not a real quota reading).\n   * Lets fail-closed callers (e.g. the registry storage push-gate) distinguish\n   * an outage from a genuine `limit: -1` (unlimited) org. Absent on real results.\n   */\n  failOpen?: boolean;\n}\n\n/**\n * Quota information for error responses.\n */\nexport interface QuotaInfo {\n  type: QuotaType;\n  limit: number;\n  used: number;\n  remaining: number;\n}\n\n/**\n * Standard API success response.\n */\nexport interface ApiSuccessResponse<T = unknown> {\n  success: true;\n  statusCode: number;\n  data?: T;\n  message?: string;\n}\n\n/**\n * Standard API error response.\n */\nexport interface ApiErrorResponse {\n  success: false;\n  statusCode: number;\n  message: string;\n  code?: string;\n  details?: unknown;\n  quota?: QuotaInfo;\n}\n\n/**\n * Combined API response type.\n */\nexport type ApiResponse<T = unknown> = ApiSuccessResponse<T> | ApiErrorResponse;\n\n/**\n * JWT payload from access tokens.\n *\n * Users can belong to multiple organizations. The token is scoped to one\n * active organization at a time. The `role` field is the user's per-org\n * role in that organization (from the UserOrganization junction collection),\n * and `isAdmin` is derived as `role === 'admin' || role === 'owner'`.\n *\n * Use `POST /auth/switch-org` to change the active organization, which\n * re-issues tokens with the new org's role and context.\n */\n/**\n * Coarse per-org membership label, DERIVED from the Roles a user is assigned\n * (the highest `grantsRole` among them; `owner` is set only by ownership\n * transfer). It is a display/authority label — driving `isAdmin`, ownership,\n * and seat accounting — NOT a permission source. Effective permissions come\n * solely from the user's assigned Roles (see `resolveUserPermissions`). Not a\n * global role.\n */\nexport type OrgRole = 'owner' | 'admin' | 'member';\n\nexport interface JwtPayload {\n  /** User ID (subject) */\n  sub: string;\n  /** Username */\n  username: string;\n  /** User email */\n  email: string;\n  /** Which kind of principal this token speaks for (see {@link PrincipalType}). */\n  principalType: PrincipalType;\n  /** How the token is used (see {@link TokenUse}); PATs are `api_key`. */\n  token_use: TokenUse;\n  /**\n   * Methods that authenticated the session (user principals). Kept on the\n   * refresh-session slot, so refresh / renew / switch-org carry it unchanged.\n   * Absent on service tokens.\n   */\n  amr?: AuthMethod[];\n  /** Assurance level (user principals). Never raised by refresh / renew / switch-org. */\n  aal?: AssuranceLevel;\n  /** Epoch seconds of the sign-in that established the session (user principals).\n   *  Never reset by refresh / renew / switch-org. */\n  auth_time?: number;\n  /**\n   * The active org REQUIRES MFA and its grace period has passed (#8).\n   *\n   * Carried as a claim so no service has to look the policy up: the org policy\n   * is enforced where the token is ISSUED (a session scoped to such an org gets\n   * `aal: 2` or is refused), and this claim is the record of that decision, for\n   * UI copy and audit rather than for a second enforcement point.\n   */\n  mfaRequired?: boolean;\n  /**\n   * BOOTSTRAP-ADMIN EXCEPTION (#8, revision 4). Set only on a session opened by\n   * the install's bootstrap admin (`BOOTSTRAP_SUPERADMIN_EMAILS`, system org)\n   * while they still have no enrolled factor. Such a session is `aal: 1` and may\n   * reach ONLY enrolment, sign-out and the routes `init-platform.sh` calls;\n   * every other service refuses it outright (see `requireAuth`). The exception\n   * closes permanently at the first enrolment and never reopens.\n   */\n  mfaEnrollmentPending?: boolean;\n  /** Per-org role in the active organization ('owner' | 'admin' | 'member'). Not a global role. */\n  role: OrgRole;\n  /** Derived: true when role is 'admin' or 'owner' in the active organization */\n  isAdmin?: boolean;\n  /**\n   * Resolved fine-grained permissions for the active org/team — the union of\n   * the permissions carried by every Role the user is assigned (see\n   * `resolveUserPermissions`). Absent on machine/scoped tokens. Superadmins are\n   * granted all permissions implicitly and may omit this. Endpoints enforce via\n   * `requirePermission(...)`.\n   */\n  permissions?: Permission[];\n  /**\n   * Global super-admin flag (cross-org). When `true`, the user is treated\n   * as a system administrator regardless of which org they're currently\n   * acting under. This is the SOLE signal for sysadmin authority — the old path\n   * (membership in the well-known \"system\" org with role admin/owner) has been\n   * removed because it conflated \"Pipeline Builder operator\" with \"real customer\n   * tenant\" in the data model. Grant sysadmin only via `isSuperAdmin`.\n   */\n  isSuperAdmin?: boolean;\n  /** Organization's quota tier. */\n  tier?: QuotaTier;\n  /** Resolved feature flags for this user/org */\n  features?: string[];\n  /**\n   * Narrow capability scope for machine/automation tokens (e.g.\n   * `'reporting:ingest'`). Absent on normal interactive user tokens. Endpoints\n   * that accept a scoped identity check this (see `hasScope`) instead of role;\n   * a scoped token is minted with minimal role for least-privilege.\n   */\n  scope?: TokenScope;\n  /** Active organization ID (from UserOrganization membership) */\n  organizationId?: string;\n  /** Active organization name */\n  organizationName?: string;\n  /**\n   * Org → team hierarchy (org-team-hierarchy proposal, phase 1).\n   * `parentOrganizationId` is the active org's direct parent; `rootOrganizationId`\n   * is the top of its ancestry chain. Both are **omitted for flat (root) orgs** —\n   * consumers should treat the effective root as `rootOrganizationId ?? organizationId`\n   * (use the shared {@link effectiveRootOrgId} accessor rather than coalescing inline).\n   * Currently every org is flat, so these are absent on all tokens today.\n   */\n  parentOrganizationId?: string;\n  /** Root organization ID of the active org's ancestry chain (see `parentOrganizationId`). */\n  rootOrganizationId?: string;\n  /**\n   * Set on tokens issued by the sysadmin impersonation flow\n   * (`POST /admin/impersonate/:userId`). Carries the original sysadmin's\n   * user id so audit events still attribute actions correctly.\n   */\n  impersonatorId?: string;\n  /**\n   * Unique token id. On an impersonation token it identifies the SESSION, so it\n   * can be revoked on its own across every service (see\n   * `TokenRevocationStore.getSessionRevocation`). Personal Access Tokens\n   * (`token_use: 'api_key'`) carry one too, validated against their own record.\n   * A `jti` alone never classifies a token — `token_use` and `impersonatorId` do.\n   */\n  jti?: string;\n  /**\n   * When true, the token is read-only — any non-GET request is rejected\n   * upstream by the platform's read-only impersonation gate. Lets\n   * sysadmins \"view as user X\" without risking a destructive action.\n   */\n  impersonationReadOnly?: boolean;\n  /**\n   * The user's `tokenVersion` at the moment this token was issued. Every\n   * privilege change (deactivate / role or tier downgrade / membership or\n   * ownership change / password change / logout-all) increments the user's\n   * server-side `tokenVersion`, so a token whose embedded version is behind the\n   * current one has been REVOKED. Platform validates this against Mongo; the\n   * stateless services validate it against a Redis-published current-version\n   * store (see `setTokenRevocationStore`). Absent on machine/service tokens.\n   */\n  tokenVersion?: number;\n  /** Token type */\n  type: 'access' | 'refresh';\n  /** Issued at timestamp */\n  iat?: number;\n  /** Expiration timestamp */\n  exp?: number;\n}\n\n/**\n * The account boundary (root org) for a token's active org.\n *\n * The account root is `rootOrganizationId ?? organizationId`: a flat (root) org\n * omits `rootOrganizationId`, so it IS its own root; a team (child) org carries\n * the top of its ancestry chain. Every account-scoped read (quota/seat/billing\n * pooling) must resolve through this coalesce rather than reading\n * `organizationId` directly — the latter silently works today (all orgs flat)\n * but would bind to the team instead of the account once teams exist.\n *\n * @returns the effective root org id, or `undefined` when neither field is set.\n */\nexport function effectiveRootOrgId(\n  payload: Pick<JwtPayload, 'organizationId' | 'rootOrganizationId'>,\n): string | undefined {\n  return payload.rootOrganizationId ?? payload.organizationId;\n}\n\n/**\n * Extended Express Request with user property.\n */\ndeclare global {\n  namespace Express {\n    interface Request {\n      user?: JwtPayload;\n    }\n  }\n}\n\n/**\n * Service configuration for internal HTTP client.\n */\nexport interface ServiceConfig {\n  /** Service hostname */\n  host: string;\n  /** Service port */\n  port: number;\n  /** Request timeout in milliseconds */\n  timeout?: number;\n}\n\n/**\n * Health check response.\n */\nexport interface HealthCheckResponse {\n  status: 'healthy' | 'unhealthy';\n  service: string;\n  timestamp: string;\n  uptime: number;\n  version?: string;\n  dependencies?: Record<string, 'connected' | 'disconnected' | 'unknown'>;\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"common.js","sourceRoot":"","sources":["../../src/types/common.ts"],"names":[],"mappings":"AAAA,+CAA+C;AAC/C,sCAAsC;AA2BtC;;;;GAIG;AACH,MAAM,CAAC,MAAM,YAAY,GAA0B,CAAC,kBAAkB,EAAE,eAAe,EAAE,MAAM,CAAC,CAAC;AAiDjG,kFAAkF;AAClF,MAAM,CAAC,MAAM,eAAe,GAA6B,CAAC,MAAM,EAAE,iBAAiB,EAAE,SAAS,CAAC,CAAC;AAChG,MAAM,CAAC,MAAM,UAAU,GAAwB,CAAC,QAAQ,EAAE,SAAS,CAAC,CAAC;AACrE,MAAM,CAAC,MAAM,YAAY,GAA0B,CAAC,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,UAAU,EAAE,QAAQ,EAAE,KAAK,CAAC,CAAC;AA8BxG;;GAEG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAG;IAC/B,SAAS,EAAE,WAAW,EAAE,UAAU,EAAE,SAAS,EAAE,cAAc;IAC7D,YAAY,EAAE,YAAY,EAAE,mBAAmB,EAAE,YAAY;CACrD,CAAC;AAEX;;;;;;;;;;;;GAYG;AACH,MAAM,UAAU,gBAAgB,CAAC,KAAc;IAC7C,OAAO,OAAO,KAAK,KAAK,QAAQ,IAAI,iBAAiB,CAAC,QAAQ,CAAC,KAAkB,CAAC,CAAC;AACrF,CAAC;AAsOD;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,kBAAkB,CAChC,OAAkE;IAElE,OAAO,OAAO,CAAC,kBAAkB,IAAI,OAAO,CAAC,cAAc,CAAC;AAC9D,CAAC","sourcesContent":["// Copyright 2026 Pipeline Builder Contributors\n// SPDX-License-Identifier: Apache-2.0\n\nimport type { Permission } from './permissions.js';\nimport type { QuotaTier } from './quota-tiers.js';\n\n/**\n * Capability scope catalog for machine/automation tokens. A scoped token carries\n * exactly one of these instead of role-based permissions; endpoints that accept a\n * scoped identity check it via `hasScope`. Kept a closed union (mirroring\n * {@link Permission}) so a typo on either the mint or the check side is a compile\n * error. Add a value here when introducing a new scoped-token surface.\n *\n * - `reporting:ingest` — the AWS event-ingestion Lambda's writes (`/reports/events`,\n *   `/reports/ingest-health`) and the incident webhook.\n * - `registry:push`    — `docker push` into the owning org's own namespace via\n *   image-registry's `/token` endpoint. Grants the raw-image write that\n *   `plugins:write` grants a person, and nothing else: a scoped token carries no\n *   permissions, so it can neither read the API nor push outside its org.\n * - `scim`             — an identity provider's SCIM 2.0 client (3b) driving\n *   `/scim/v2/Users` and `/scim/v2/Groups` for the key's OWN org. It provisions\n *   and deactivates memberships and moves people between directory groups; it\n *   can never read or write anything else, and — because a scoped token carries\n *   no permissions — it cannot author the group → Role rules its syncs resolve\n *   through. Only a service-account key may carry it; a person's token never does.\n */\nexport type TokenScope = 'reporting:ingest' | 'registry:push' | 'scim';\n\n/**\n * Runtime catalog of {@link TokenScope} (a union is erased at runtime). This is\n * the ONE allowlist every mint path validates against — platform's key/token\n * issue routes included — so a new scope is added in exactly one place.\n */\nexport const TOKEN_SCOPES: readonly TokenScope[] = ['reporting:ingest', 'registry:push', 'scim'];\n\n/**\n * What kind of principal a token speaks for. Auth decisions branch on this claim\n * — never on the shape of `sub` or on which optional claims happen to be present.\n *\n * - `user`            — a person (session, machine session, PAT or impersonation).\n * - `service_account` — a non-human account owned by ONE org, holding org Roles\n *                       and authenticating with a `pb_sa_…` key exchanged at\n *                       platform. Never satisfies an assurance/step-up gate.\n * - `service`         — an internal Pipeline Builder service ({@link signServiceToken}).\n */\nexport type PrincipalType = 'user' | 'service_account' | 'service';\n\n/**\n * How a token is used. `access` is a session-style access token (interactive,\n * machine-session or service); `api_key` is a standalone credential tracked by\n * its own record — a Personal Access Token or a service-account key, named by\n * `jti`.\n */\nexport type TokenUse = 'access' | 'api_key';\n\n/**\n * Authentication methods (`amr`, RFC 8176 style) that established a user's\n * session. `pwd` password sign-in; `oauth` social sign-in (Google, GitHub …);\n * `sso` per-org OIDC single sign-on; `webauthn` a passkey (WebAuthn assertion\n * with user verification); `stepup` a step-up re-verification token; `mfa` a\n * second factor was presented as well — today an authenticator-app code (TOTP)\n * or one of its recovery codes, so it appears ALONGSIDE the method that\n * identified the user (`['pwd', 'mfa']`), never on its own.\n */\nexport type AuthMethod = 'pwd' | 'oauth' | 'sso' | 'webauthn' | 'stepup' | 'mfa';\n\n/**\n * Authenticator assurance level of the session a token speaks for (#8).\n *\n * - `1` — one factor: a password, a social sign-in, or SSO through an IdP the\n *   org has NOT marked as enforcing MFA.\n * - `2` — MFA-grade: a passkey asserted with user verification, a password plus\n *   an authenticator-app code, or SSO through an IdP the org HAS marked as\n *   enforcing MFA (providers don't send `amr` reliably, so the org's own\n *   statement about its IdP is the signal).\n *\n * Fixed when the session is opened and stored on its refresh-session slot, so\n * refresh / renewal / switch-org copy it verbatim and can never RAISE it —\n * earning aal 2 always means authenticating again with a second factor.\n */\nexport type AssuranceLevel = 1 | 2;\n\n/** Runtime catalogs for the claim unions above (a union is erased at runtime). */\nexport const PRINCIPAL_TYPES: readonly PrincipalType[] = ['user', 'service_account', 'service'];\nexport const TOKEN_USES: readonly TokenUse[] = ['access', 'api_key'];\nexport const AUTH_METHODS: readonly AuthMethod[] = ['pwd', 'oauth', 'sso', 'webauthn', 'stepup', 'mfa'];\n\n/**\n * Quota type identifiers.\n *\n * - `plugins` / `pipelines` — count of created entities\n * - `apiCalls` — generic API call count (read-heavy paths)\n * - `aiCalls` — AI provider invocations (counted separately because each call\n *   has external dollar cost; sized smaller than apiCalls per tier)\n * - `storageBytes` — registry storage budget per org. Unlike the others\n *   (which count discrete events), this is a measured total recomputed\n *   on demand. Incremented by the image-registry's push-gate before\n *   issuing a token whose scope includes `push`; the GC scheduler\n *   eventually frees the bytes, then the next push-gate check reads\n *   the lower value. NOT a counter-style quota in the sense of\n *   `incrementUsage` — the registry pushes the measured total via\n *   `updateLimits`/`resetUsage` flows. Tier limits are bytes.\n * - `dashboards` / `alertRules` / `alertDestinations` / `idpConfigs` —\n *   resource-count quotas added to close per-org DoS surfaces in the\n *   user-editable feature tables. Without these caps a single org could\n *   spam thousands of dashboards / rules and bloat the shared Postgres /\n *   Mongo working sets. Counted at create time; decremented on delete.\n */\n// NOTE: `seats` is intentionally NOT here. It's a tier limit (QuotaTierLimits)\n// enforced by comparing the org's LIVE member count at invite time — not an\n// incrementing per-period counter like the consumable quotas below.\nexport type QuotaType =\n  | 'plugins' | 'pipelines' | 'apiCalls' | 'aiCalls' | 'storageBytes'\n  | 'dashboards' | 'alertRules' | 'alertDestinations' | 'idpConfigs';\n\n/**\n * Valid quota type values.\n */\nexport const VALID_QUOTA_TYPES = [\n  'plugins', 'pipelines', 'apiCalls', 'aiCalls', 'storageBytes',\n  'dashboards', 'alertRules', 'alertDestinations', 'idpConfigs',\n] as const;\n\n/**\n * Type guard to check if a value is a valid QuotaType.\n *\n * @param value - Value to check\n * @returns True if value is a valid QuotaType\n *\n * @example\n * ```typescript\n * if (isValidQuotaType(req.body.quotaType)) {\n *   // quotaType is guaranteed to be QuotaType\n * }\n * ```\n */\nexport function isValidQuotaType(value: unknown): value is QuotaType {\n  return typeof value === 'string' && VALID_QUOTA_TYPES.includes(value as QuotaType);\n}\n\n/**\n * Result from quota check operation.\n */\nexport interface QuotaCheckResult {\n  /** Whether the request is allowed */\n  allowed: boolean;\n  /** Maximum quota limit (-1 for unlimited) */\n  limit: number;\n  /** Current usage count */\n  used: number;\n  /** Remaining quota (-1 for unlimited) */\n  remaining: number;\n  /** ISO timestamp when quota resets */\n  resetAt: string;\n  /** Whether quota is unlimited */\n  unlimited: boolean;\n  /**\n   * True ONLY when this result is the fail-open sentinel returned because the\n   * quota service was unreachable / returned non-ok (not a real quota reading).\n   * Lets fail-closed callers (e.g. the registry storage push-gate) distinguish\n   * an outage from a genuine `limit: -1` (unlimited) org. Absent on real results.\n   */\n  failOpen?: boolean;\n}\n\n/**\n * Quota information for error responses.\n */\nexport interface QuotaInfo {\n  type: QuotaType;\n  limit: number;\n  used: number;\n  remaining: number;\n}\n\n/**\n * Standard API success response.\n */\nexport interface ApiSuccessResponse<T = unknown> {\n  success: true;\n  statusCode: number;\n  data?: T;\n  message?: string;\n}\n\n/**\n * Standard API error response.\n */\nexport interface ApiErrorResponse {\n  success: false;\n  statusCode: number;\n  message: string;\n  code?: string;\n  details?: unknown;\n  quota?: QuotaInfo;\n}\n\n/**\n * Combined API response type.\n */\nexport type ApiResponse<T = unknown> = ApiSuccessResponse<T> | ApiErrorResponse;\n\n/**\n * JWT payload from access tokens.\n *\n * Users can belong to multiple organizations. The token is scoped to one\n * active organization at a time. The `role` field is the user's per-org\n * role in that organization (from the UserOrganization junction collection),\n * and `isAdmin` is derived as `role === 'admin' || role === 'owner'`.\n *\n * Use `POST /auth/switch-org` to change the active organization, which\n * re-issues tokens with the new org's role and context.\n */\n/**\n * Coarse per-org membership label, DERIVED from the Roles a user is assigned\n * (the highest `grantsRole` among them; `owner` is set only by ownership\n * transfer). It is a display/authority label — driving `isAdmin`, ownership,\n * and seat accounting — NOT a permission source. Effective permissions come\n * solely from the user's assigned Roles (see `resolveUserPermissions`). Not a\n * global role.\n */\nexport type OrgRole = 'owner' | 'admin' | 'member';\n\nexport interface JwtPayload {\n  /** User ID (subject) */\n  sub: string;\n  /** Username */\n  username: string;\n  /** User email */\n  email: string;\n  /** Which kind of principal this token speaks for (see {@link PrincipalType}). */\n  principalType: PrincipalType;\n  /** How the token is used (see {@link TokenUse}); PATs are `api_key`. */\n  token_use: TokenUse;\n  /**\n   * Methods that authenticated the session (user principals). Kept on the\n   * refresh-session slot, so refresh / renew / switch-org carry it unchanged.\n   * Absent on service tokens.\n   */\n  amr?: AuthMethod[];\n  /** Assurance level (user principals). Never raised by refresh / renew / switch-org. */\n  aal?: AssuranceLevel;\n  /** Epoch seconds of the sign-in that established the session (user principals).\n   *  Never reset by refresh / renew / switch-org. */\n  auth_time?: number;\n  /**\n   * The active org REQUIRES MFA and its grace period has passed (#8).\n   *\n   * Carried as a claim so no service has to look the policy up: the org policy\n   * is enforced where the token is ISSUED (a session scoped to such an org gets\n   * `aal: 2` or is refused), and this claim is the record of that decision, for\n   * UI copy and audit rather than for a second enforcement point.\n   */\n  mfaRequired?: boolean;\n  /**\n   * The active org's \"administrative actions require MFA\" policy\n   * (`adminActionsRequireMfa`, strictest across the org and its ancestors).\n   * Present — and always `2` — only when the policy is on. It is resolved when\n   * the token is ISSUED, so services that can't read the org document still know\n   * the policy: `requireOrgAdminAssurance` refuses an `aal: 1` session on an\n   * administrative route when this claim is present. Changing the policy bumps\n   * every affected member's `tokenVersion`, so the claim can't go stale.\n   */\n  org_admin_aal?: 2;\n  /**\n   * BOOTSTRAP-ADMIN EXCEPTION (#8, revision 4). Set only on a session opened by\n   * the install's bootstrap admin (`BOOTSTRAP_SUPERADMIN_EMAILS`, system org)\n   * while they still have no enrolled factor. Such a session is `aal: 1` and may\n   * reach ONLY enrolment, sign-out and the routes `init-platform.sh` calls;\n   * every other service refuses it outright (see `requireAuth`). The exception\n   * closes permanently at the first enrolment and never reopens.\n   */\n  mfaEnrollmentPending?: boolean;\n  /** Per-org role in the active organization ('owner' | 'admin' | 'member'). Not a global role. */\n  role: OrgRole;\n  /** Derived: true when role is 'admin' or 'owner' in the active organization */\n  isAdmin?: boolean;\n  /**\n   * Resolved fine-grained permissions for the active org/team — the union of\n   * the permissions carried by every Role the user is assigned (see\n   * `resolveUserPermissions`). Absent on machine/scoped tokens. Superadmins are\n   * granted all permissions implicitly and may omit this. Endpoints enforce via\n   * `requirePermission(...)`.\n   */\n  permissions?: Permission[];\n  /**\n   * Global super-admin flag (cross-org). When `true`, the user is treated\n   * as a system administrator regardless of which org they're currently\n   * acting under. This is the SOLE signal for sysadmin authority — the old path\n   * (membership in the well-known \"system\" org with role admin/owner) has been\n   * removed because it conflated \"Pipeline Builder operator\" with \"real customer\n   * tenant\" in the data model. Grant sysadmin only via `isSuperAdmin`.\n   */\n  isSuperAdmin?: boolean;\n  /** Organization's quota tier. */\n  tier?: QuotaTier;\n  /** Resolved feature flags for this user/org */\n  features?: string[];\n  /**\n   * Narrow capability scope for machine/automation tokens (e.g.\n   * `'reporting:ingest'`). Absent on normal interactive user tokens. Endpoints\n   * that accept a scoped identity check this (see `hasScope`) instead of role;\n   * a scoped token is minted with minimal role for least-privilege.\n   */\n  scope?: TokenScope;\n  /**\n   * The token's `permissions` were NARROWED to a catalog subset chosen when the\n   * credential was created (a permission-scoped personal access key or machine\n   * token). The claim is the record that `permissions` is the INTERSECTION of\n   * that subset with the holder's current Roles — not their full authority — so\n   * anything the token mints can only be narrower still, and it never carries\n   * `isSuperAdmin` or an admin `role` (both would bypass the subset). Only ever\n   * `true`; absent on unrestricted tokens.\n   */\n  permissionsRestricted?: boolean;\n  /** Active organization ID (from UserOrganization membership) */\n  organizationId?: string;\n  /** Active organization name */\n  organizationName?: string;\n  /**\n   * Org → team hierarchy (org-team-hierarchy proposal, phase 1).\n   * `parentOrganizationId` is the active org's direct parent; `rootOrganizationId`\n   * is the top of its ancestry chain. Both are **omitted for flat (root) orgs** —\n   * consumers should treat the effective root as `rootOrganizationId ?? organizationId`\n   * (use the shared {@link effectiveRootOrgId} accessor rather than coalescing inline).\n   * Currently every org is flat, so these are absent on all tokens today.\n   */\n  parentOrganizationId?: string;\n  /** Root organization ID of the active org's ancestry chain (see `parentOrganizationId`). */\n  rootOrganizationId?: string;\n  /**\n   * Set on tokens issued by the sysadmin impersonation flow\n   * (`POST /admin/impersonate/:userId`). Carries the original sysadmin's\n   * user id so audit events still attribute actions correctly.\n   */\n  impersonatorId?: string;\n  /**\n   * Unique token id. On an impersonation token it identifies the SESSION, so it\n   * can be revoked on its own across every service (see\n   * `TokenRevocationStore.getSessionRevocation`). Personal Access Tokens\n   * (`token_use: 'api_key'`) carry one too, validated against their own record.\n   * A `jti` alone never classifies a token — `token_use` and `impersonatorId` do.\n   */\n  jti?: string;\n  /**\n   * When true, the token is read-only — any non-GET request is rejected\n   * upstream by the platform's read-only impersonation gate. Lets\n   * sysadmins \"view as user X\" without risking a destructive action.\n   */\n  impersonationReadOnly?: boolean;\n  /**\n   * The user's `tokenVersion` at the moment this token was issued. Every\n   * privilege change (deactivate / role or tier downgrade / membership or\n   * ownership change / password change / logout-all) increments the user's\n   * server-side `tokenVersion`, so a token whose embedded version is behind the\n   * current one has been REVOKED. Platform validates this against Mongo; the\n   * stateless services validate it against a Redis-published current-version\n   * store (see `setTokenRevocationStore`). Absent on machine/service tokens.\n   */\n  tokenVersion?: number;\n  /** Token type */\n  type: 'access' | 'refresh';\n  /** Issued at timestamp */\n  iat?: number;\n  /** Expiration timestamp */\n  exp?: number;\n}\n\n/**\n * The account boundary (root org) for a token's active org.\n *\n * The account root is `rootOrganizationId ?? organizationId`: a flat (root) org\n * omits `rootOrganizationId`, so it IS its own root; a team (child) org carries\n * the top of its ancestry chain. Every account-scoped read (quota/seat/billing\n * pooling) must resolve through this coalesce rather than reading\n * `organizationId` directly — the latter silently works today (all orgs flat)\n * but would bind to the team instead of the account once teams exist.\n *\n * @returns the effective root org id, or `undefined` when neither field is set.\n */\nexport function effectiveRootOrgId(\n  payload: Pick<JwtPayload, 'organizationId' | 'rootOrganizationId'>,\n): string | undefined {\n  return payload.rootOrganizationId ?? payload.organizationId;\n}\n\n/**\n * Extended Express Request with user property.\n */\ndeclare global {\n  namespace Express {\n    interface Request {\n      user?: JwtPayload;\n    }\n  }\n}\n\n/**\n * Service configuration for internal HTTP client.\n */\nexport interface ServiceConfig {\n  /** Service hostname */\n  host: string;\n  /** Service port */\n  port: number;\n  /** Request timeout in milliseconds */\n  timeout?: number;\n}\n\n/**\n * Health check response.\n */\nexport interface HealthCheckResponse {\n  status: 'healthy' | 'unhealthy';\n  service: string;\n  timestamp: string;\n  uptime: number;\n  version?: string;\n  dependencies?: Record<string, 'connected' | 'disconnected' | 'unknown'>;\n}\n"]}

package/lib/types/http.d.ts

@@ -22,6 +22,10 @@ export interface HttpRequest {
         sub?: string;
         organizationId?: string;
         role?: string;
+        /** `user` | `service_account` | `service` — decides whether the
+         *  client-settable `x-org-id` header may name the tenant (see
+         *  `utils/identity.ts`). */
+        principalType?: string;
         [key: string]: unknown;
     };
 }

package/lib/types/http.js

@@ -1,4 +1,4 @@
 // Copyright 2026 Pipeline Builder Contributors
 // SPDX-License-Identifier: Apache-2.0
 export {};
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaHR0cC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy90eXBlcy9odHRwLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLCtDQUErQztBQUMvQyxzQ0FBc0MiLCJzb3VyY2VzQ29udGVudCI6WyIvLyBDb3B5cmlnaHQgMjAyNiBQaXBlbGluZSBCdWlsZGVyIENvbnRyaWJ1dG9yc1xuLy8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEFwYWNoZS0yLjBcblxuLyoqXG4gKiBHZW5lcmljIEhUVFAgaGVhZGVycyByZXByZXNlbnRhdGlvbi5cbiAqL1xuZXhwb3J0IGludGVyZmFjZSBIdHRwSGVhZGVycyB7XG4gIFtrZXk6IHN0cmluZ106IHN0cmluZyB8IHN0cmluZ1tdIHwgdW5kZWZpbmVkO1xufVxuXG4vKipcbiAqIEdlbmVyaWMgSFRUUCByZXF1ZXN0IGludGVyZmFjZS5cbiAqIFJlcHJlc2VudHMgdGhlIG1pbmltYWwgcmVxdWVzdCBzaGFwZSBuZWVkZWQgYnkgYXBpLWNvcmUgdXRpbGl0aWVzLlxuICovXG5leHBvcnQgaW50ZXJmYWNlIEh0dHBSZXF1ZXN0IHtcbiAgLyoqIFJlcXVlc3QgaGVhZGVycyAqL1xuICBoZWFkZXJzOiBIdHRwSGVhZGVycztcbiAgLyoqIFJvdXRlIHBhcmFtZXRlcnMgKi9cbiAgcGFyYW1zOiBSZWNvcmQ8c3RyaW5nLCBzdHJpbmcgfCBzdHJpbmdbXSB8IHVuZGVmaW5lZD47XG4gIC8qKiBRdWVyeSBwYXJhbWV0ZXJzICovXG4gIHF1ZXJ5OiBSZWNvcmQ8c3RyaW5nLCB1bmtub3duPjtcbiAgLyoqIEF1dGhlbnRpY2F0ZWQgdXNlciAoaWYgcHJlc2VudCkuIGBzdWJgIGlzIHRoZSBPSURDLXN0YW5kYXJkIHN1YmplY3RcbiAgICogICg9IHVzZXIgaWQpOyBoaWdoZXItbGV2ZWwgbGF5ZXJzIG1heSBhdHRhY2ggYWRkaXRpb25hbCBmaWVsZHMsIGhlbmNlXG4gICAqICB0aGUgaW5kZXggc2lnbmF0dXJlLiAqL1xuICB1c2VyPzoge1xuICAgIHN1Yj86IHN0cmluZztcbiAgICBvcmdhbml6YXRpb25JZD86IHN0cmluZztcbiAgICByb2xlPzogc3RyaW5nO1xuICAgIFtrZXk6IHN0cmluZ106IHVua25vd247XG4gIH07XG59XG5cbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaHR0cC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy90eXBlcy9odHRwLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLCtDQUErQztBQUMvQyxzQ0FBc0MiLCJzb3VyY2VzQ29udGVudCI6WyIvLyBDb3B5cmlnaHQgMjAyNiBQaXBlbGluZSBCdWlsZGVyIENvbnRyaWJ1dG9yc1xuLy8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEFwYWNoZS0yLjBcblxuLyoqXG4gKiBHZW5lcmljIEhUVFAgaGVhZGVycyByZXByZXNlbnRhdGlvbi5cbiAqL1xuZXhwb3J0IGludGVyZmFjZSBIdHRwSGVhZGVycyB7XG4gIFtrZXk6IHN0cmluZ106IHN0cmluZyB8IHN0cmluZ1tdIHwgdW5kZWZpbmVkO1xufVxuXG4vKipcbiAqIEdlbmVyaWMgSFRUUCByZXF1ZXN0IGludGVyZmFjZS5cbiAqIFJlcHJlc2VudHMgdGhlIG1pbmltYWwgcmVxdWVzdCBzaGFwZSBuZWVkZWQgYnkgYXBpLWNvcmUgdXRpbGl0aWVzLlxuICovXG5leHBvcnQgaW50ZXJmYWNlIEh0dHBSZXF1ZXN0IHtcbiAgLyoqIFJlcXVlc3QgaGVhZGVycyAqL1xuICBoZWFkZXJzOiBIdHRwSGVhZGVycztcbiAgLyoqIFJvdXRlIHBhcmFtZXRlcnMgKi9cbiAgcGFyYW1zOiBSZWNvcmQ8c3RyaW5nLCBzdHJpbmcgfCBzdHJpbmdbXSB8IHVuZGVmaW5lZD47XG4gIC8qKiBRdWVyeSBwYXJhbWV0ZXJzICovXG4gIHF1ZXJ5OiBSZWNvcmQ8c3RyaW5nLCB1bmtub3duPjtcbiAgLyoqIEF1dGhlbnRpY2F0ZWQgdXNlciAoaWYgcHJlc2VudCkuIGBzdWJgIGlzIHRoZSBPSURDLXN0YW5kYXJkIHN1YmplY3RcbiAgICogICg9IHVzZXIgaWQpOyBoaWdoZXItbGV2ZWwgbGF5ZXJzIG1heSBhdHRhY2ggYWRkaXRpb25hbCBmaWVsZHMsIGhlbmNlXG4gICAqICB0aGUgaW5kZXggc2lnbmF0dXJlLiAqL1xuICB1c2VyPzoge1xuICAgIHN1Yj86IHN0cmluZztcbiAgICBvcmdhbml6YXRpb25JZD86IHN0cmluZztcbiAgICByb2xlPzogc3RyaW5nO1xuICAgIC8qKiBgdXNlcmAgfCBgc2VydmljZV9hY2NvdW50YCB8IGBzZXJ2aWNlYCDigJQgZGVjaWRlcyB3aGV0aGVyIHRoZVxuICAgICAqICBjbGllbnQtc2V0dGFibGUgYHgtb3JnLWlkYCBoZWFkZXIgbWF5IG5hbWUgdGhlIHRlbmFudCAoc2VlXG4gICAgICogIGB1dGlscy9pZGVudGl0eS50c2ApLiAqL1xuICAgIHByaW5jaXBhbFR5cGU/OiBzdHJpbmc7XG4gICAgW2tleTogc3RyaW5nXTogdW5rbm93bjtcbiAgfTtcbn1cblxuIl19

package/lib/types/index.d.ts

@@ -8,4 +8,5 @@ export * from './http.js';
 export * from './quota-tiers.js';
 export * from './feature-flags.js';
 export * from './permissions.js';
+export * from './metadata-keys.js';
 export * from './audit-events.js';

package/lib/types/index.js

@@ -10,5 +10,6 @@ export * from './http.js';
 export * from './quota-tiers.js';
 export * from './feature-flags.js';
 export * from './permissions.js';
+export * from './metadata-keys.js';
 export * from './audit-events.js';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdHlwZXMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsK0NBQStDO0FBQy9DLHNDQUFzQztBQUV0QyxjQUFjLGtCQUFrQixDQUFDO0FBQ2pDLGNBQWMsYUFBYSxDQUFDO0FBQzVCLGNBQWMsZUFBZSxDQUFDO0FBQzlCLGNBQWMsdUJBQXVCLENBQUM7QUFDdEMsY0FBYyx3QkFBd0IsQ0FBQztBQUN2QyxjQUFjLGlCQUFpQixDQUFDO0FBQ2hDLGNBQWMsV0FBVyxDQUFDO0FBQzFCLGNBQWMsa0JBQWtCLENBQUM7QUFDakMsY0FBYyxvQkFBb0IsQ0FBQztBQUNuQyxjQUFjLGtCQUFrQixDQUFDO0FBQ2pDLGNBQWMsbUJBQW1CLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvLyBDb3B5cmlnaHQgMjAyNiBQaXBlbGluZSBCdWlsZGVyIENvbnRyaWJ1dG9yc1xuLy8gU1BEWC1MaWNlbnNlLUlkZW50aWZpZXI6IEFwYWNoZS0yLjBcblxuZXhwb3J0ICogZnJvbSAnLi9lcnJvci1jb2Rlcy5qcyc7XG5leHBvcnQgKiBmcm9tICcuL2NvbW1vbi5qcyc7XG5leHBvcnQgKiBmcm9tICcuL3BpcGVsaW5lLmpzJztcbmV4cG9ydCAqIGZyb20gJy4vY2F0YWxvZy1tZXRhZGF0YS5qcyc7XG5leHBvcnQgKiBmcm9tICcuL3BpcGVsaW5lLXRlbXBsYXRlLmpzJztcbmV4cG9ydCAqIGZyb20gJy4vdmlzaWJpbGl0eS5qcyc7XG5leHBvcnQgKiBmcm9tICcuL2h0dHAuanMnO1xuZXhwb3J0ICogZnJvbSAnLi9xdW90YS10aWVycy5qcyc7XG5leHBvcnQgKiBmcm9tICcuL2ZlYXR1cmUtZmxhZ3MuanMnO1xuZXhwb3J0ICogZnJvbSAnLi9wZXJtaXNzaW9ucy5qcyc7XG5leHBvcnQgKiBmcm9tICcuL2F1ZGl0LWV2ZW50cy5qcyc7XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdHlwZXMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsK0NBQStDO0FBQy9DLHNDQUFzQztBQUV0QyxjQUFjLGtCQUFrQixDQUFDO0FBQ2pDLGNBQWMsYUFBYSxDQUFDO0FBQzVCLGNBQWMsZUFBZSxDQUFDO0FBQzlCLGNBQWMsdUJBQXVCLENBQUM7QUFDdEMsY0FBYyx3QkFBd0IsQ0FBQztBQUN2QyxjQUFjLGlCQUFpQixDQUFDO0FBQ2hDLGNBQWMsV0FBVyxDQUFDO0FBQzFCLGNBQWMsa0JBQWtCLENBQUM7QUFDakMsY0FBYyxvQkFBb0IsQ0FBQztBQUNuQyxjQUFjLGtCQUFrQixDQUFDO0FBQ2pDLGNBQWMsb0JBQW9CLENBQUM7QUFDbkMsY0FBYyxtQkFBbUIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8vIENvcHlyaWdodCAyMDI2IFBpcGVsaW5lIEJ1aWxkZXIgQ29udHJpYnV0b3JzXG4vLyBTUERYLUxpY2Vuc2UtSWRlbnRpZmllcjogQXBhY2hlLTIuMFxuXG5leHBvcnQgKiBmcm9tICcuL2Vycm9yLWNvZGVzLmpzJztcbmV4cG9ydCAqIGZyb20gJy4vY29tbW9uLmpzJztcbmV4cG9ydCAqIGZyb20gJy4vcGlwZWxpbmUuanMnO1xuZXhwb3J0ICogZnJvbSAnLi9jYXRhbG9nLW1ldGFkYXRhLmpzJztcbmV4cG9ydCAqIGZyb20gJy4vcGlwZWxpbmUtdGVtcGxhdGUuanMnO1xuZXhwb3J0ICogZnJvbSAnLi92aXNpYmlsaXR5LmpzJztcbmV4cG9ydCAqIGZyb20gJy4vaHR0cC5qcyc7XG5leHBvcnQgKiBmcm9tICcuL3F1b3RhLXRpZXJzLmpzJztcbmV4cG9ydCAqIGZyb20gJy4vZmVhdHVyZS1mbGFncy5qcyc7XG5leHBvcnQgKiBmcm9tICcuL3Blcm1pc3Npb25zLmpzJztcbmV4cG9ydCAqIGZyb20gJy4vbWV0YWRhdGEta2V5cy5qcyc7XG5leHBvcnQgKiBmcm9tICcuL2F1ZGl0LWV2ZW50cy5qcyc7XG4iXX0=