@c15t/backend 2.0.0-rc.0 → 2.0.0-rc.10

package/{dist → dist-types}/db/tenant-scope.d.ts

@@ -17,4 +17,3 @@ type ORM = ReturnType<InferFumaDB<typeof LatestDB>['orm']>;
  */
 export declare function withTenantScope(db: ORM, tenantId: string): ORM;
 export {};
-//# sourceMappingURL=tenant-scope.d.ts.map

package/dist-types/define-config.d.ts

@@ -0,0 +1,17 @@
+import type { C15TOptions } from './types';
+/**
+ * c15t backend config accepted by `defineConfig`.
+ *
+ * Keep this as an intersection with `C15TOptions` (instead of `Omit`) so
+ * TypeScript preserves property-level JSDoc in editor completions.
+ */
+export type C15TConfig = C15TOptions & {
+    /**
+     * Logger config is managed internally and is not supported via config files.
+     */
+    logger?: never;
+};
+/**
+ * Helper for typed backend configuration in `c15t-backend.config.ts`.
+ */
+export declare const defineConfig: (config: C15TConfig) => C15TConfig;

package/dist-types/edge/index.d.ts

@@ -0,0 +1,5 @@
+export type { InitPayload } from './init-handler';
+export { unstable_c15tEdgeInit } from './init-handler';
+export type { C15TConsentResolverOptions, CategoryConsent, ResolvedConsent, } from './resolve-consent';
+export { unstable_resolveConsent } from './resolve-consent';
+export type { C15TEdgeOptions } from './types';

package/dist-types/edge/init-handler.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Edge-compatible /init handler — runs as a pure Request → Response function
+ * without Hono or a database adapter.
+ *
+ * @packageDocumentation
+ */
+import { type InitPayload } from '../handlers/init/resolve-init';
+import type { C15TEdgeOptions } from './types';
+export type { InitPayload };
+/**
+ * Creates an edge-compatible /init handler.
+ *
+ * The returned function accepts a standard `Request` and returns a `Response`.
+ * It has no dependency on Hono or any database adapter, making it suitable for
+ * edge runtimes such as Vercel Middleware, Cloudflare Workers, or Deno Deploy.
+ *
+ * @experimental This API is unstable in 2.0 and may change or be removed.
+ *
+ * @example
+ * ```ts
+ * // middleware.ts (Vercel Edge)
+ * import { unstable_c15tEdgeInit } from '@c15t/backend/edge';
+ *
+ * const initHandler = unstable_c15tEdgeInit({
+ *   trustedOrigins: ['https://myapp.com'],
+ *   policyPacks: [
+ *     { id: 'eu', match: { countries: ['DE', 'FR'] }, consent: { model: 'opt-in' }, ui: { mode: 'banner' } },
+ *   ],
+ *   policySnapshot: { signingKey: process.env.SNAPSHOT_KEY! },
+ * });
+ *
+ * export async function middleware(request: Request) {
+ *   const url = new URL(request.url);
+ *   if (url.pathname === '/api/consent/init') {
+ *     return initHandler(request);
+ *   }
+ * }
+ * ```
+ */
+export declare function unstable_c15tEdgeInit(options: C15TEdgeOptions): (request: Request) => Promise<Response>;

package/dist-types/edge/resolve-consent.d.ts

@@ -0,0 +1,80 @@
+/**
+ * Lightweight edge consent resolver — resolves policy + default consent
+ * categories from geo headers without the full /init payload.
+ *
+ * Designed for enterprise customers who maintain their own consent cookie
+ * and need to know which categories to load in middleware.
+ *
+ * @packageDocumentation
+ */
+import type { Logger } from '@c15t/logger';
+import type { C15TEdgeOptions } from './types';
+/**
+ * Options for the consent resolver — a subset of C15TEdgeOptions
+ * containing only what's needed for policy resolution.
+ */
+export type C15TConsentResolverOptions = Pick<C15TEdgeOptions, 'policyPacks' | 'disableGeoLocation'>;
+/**
+ * Default consent state for a single category.
+ */
+export interface CategoryConsent {
+    /** Whether this category is granted by default (before user interaction). */
+    granted: boolean;
+    /** Whether the user can toggle this category off. */
+    required: boolean;
+}
+/**
+ * Result of resolving consent defaults for a request.
+ */
+export interface ResolvedConsent {
+    /** The jurisdiction code for this visitor (GDPR, CCPA, etc.) */
+    jurisdiction: string;
+    /** Visitor's detected location. */
+    location: {
+        countryCode: string | null;
+        regionCode: string | null;
+    };
+    /** The resolved consent model (opt-in, opt-out, none, iab). */
+    model: string;
+    /** The matched policy ID, or null if no policy matched. */
+    policyId: string | null;
+    /** Default consent state per category. */
+    defaults: Record<string, CategoryConsent>;
+    /** Whether a consent banner/dialog should be shown. */
+    showBanner: boolean;
+    /** Whether the GPC (Global Privacy Control) signal is active. */
+    gpc: boolean;
+}
+/**
+ * Resolves consent policy and default category states from a request.
+ *
+ * Fully synchronous — no async, no fetch calls, no crypto.
+ *
+ * This is a lightweight alternative to `unstable_c15tEdgeInit` for enterprise
+ * customers who manage their own consent cookie. It returns the resolved
+ * policy and default consent state without translations, GVL, branding,
+ * or snapshot tokens.
+ *
+ * @experimental This API is unstable in 2.0 and may change or be removed.
+ *
+ * @example
+ * ```ts
+ * import { unstable_resolveConsent } from '@c15t/backend/edge';
+ *
+ * export function middleware(request: Request) {
+ *   const consent = unstable_resolveConsent(request, {
+ *     policyPacks: [
+ *       { id: 'eu', match: { countries: ['DE', 'FR'] }, consent: { model: 'opt-in', categories: ['necessary', 'marketing', 'measurement'] }, ui: { mode: 'banner' } },
+ *       { id: 'us', match: { isDefault: true }, consent: { model: 'opt-out', categories: ['necessary', 'marketing', 'measurement'] }, ui: { mode: 'banner' } },
+ *     ],
+ *   });
+ *
+ *   // consent.defaults => { necessary: { granted: true, required: true }, marketing: { granted: false, required: false }, ... }
+ *   // consent.model => "opt-in"
+ *   // consent.showBanner => true
+ *
+ *   // Read your own cookie, merge with consent.defaults, decide what to load
+ * }
+ * ```
+ */
+export declare function unstable_resolveConsent(request: Request, options: C15TConsentResolverOptions, logger?: Logger): ResolvedConsent;

package/dist-types/edge/types.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Edge handler types — the minimal subset of C15TOptions needed to run /init
+ * without a database adapter.
+ *
+ * @packageDocumentation
+ */
+import type { C15TOptions } from '../types';
+/**
+ * Configuration for the edge init handler.
+ * This is a strict subset of {@link C15TOptions} containing only the fields
+ * needed for consent policy resolution — no database adapter required.
+ */
+export type C15TEdgeOptions = Pick<C15TOptions, 'appName' | 'tenantId' | 'trustedOrigins' | 'disableGeoLocation' | 'customTranslations' | 'i18n' | 'policyPacks' | 'branding' | 'iab' | 'cache' | 'policySnapshot' | 'legalDocumentSnapshot' | 'telemetry' | 'logger'>;

package/{dist → dist-types}/handlers/consent/check.handler.d.ts

@@ -21,4 +21,3 @@ export declare const checkConsentHandler: (c: Context) => Promise<Response & imp
         };
     };
 }, import("hono/utils/http-status").ContentfulStatusCode, "json">>;
-//# sourceMappingURL=check.handler.d.ts.map

package/{src/handlers/consent/index.ts → dist-types/handlers/consent/index.d.ts}

@@ -8,5 +8,4 @@
  *
  * @packageDocumentation
  */
-
 export { checkConsentHandler } from './check.handler';

package/{dist → dist-types}/handlers/init/geo.d.ts

@@ -16,7 +16,7 @@ export declare function checkJurisdiction(countryCode: string | null, regionCode
  * @param options - The C15T options
  * @returns The location object with countryCode and regionCode
  */
-export declare function getLocation(request: Request, options: C15TOptions): Promise<{
+export declare function getLocation(request: Request, options: Pick<C15TOptions, 'disableGeoLocation'>): Promise<{
     countryCode: string | null;
     regionCode: string | null;
 }>;
@@ -30,5 +30,4 @@ export declare function getLocation(request: Request, options: C15TOptions): Pro
 export declare function getJurisdiction(location: {
     countryCode: string | null;
     regionCode: string | null;
-}, options: C15TOptions): JurisdictionCode;
-//# sourceMappingURL=geo.d.ts.map
+}, options: Pick<C15TOptions, 'disableGeoLocation'>): JurisdictionCode;

package/{dist → dist-types}/handlers/init/index.d.ts

@@ -41,7 +41,7 @@ export declare function buildResponse({ jurisdiction, location, acceptLanguage,
         translations: import("@c15t/translations").CompleteTranslations;
         language: string;
     };
-    branding: "c15t" | "consent" | "none";
+    branding: "c15t" | "consent" | "none" | "inth";
     gvl: {
         gvlSpecificationVersion: number;
         vendorListVersion: number;
@@ -153,5 +153,4 @@ export declare function buildResponse({ jurisdiction, location, acceptLanguage,
     }[] | undefined;
 };
 export { checkJurisdiction, getJurisdiction, getLocation } from './geo';
-export { getTranslations, getTranslationsData } from './translations';
-//# sourceMappingURL=index.d.ts.map
+export { getTranslations, getTranslationsData, listProfiles, validateMessages, } from './translations';

package/dist-types/handlers/init/policy.d.ts

@@ -0,0 +1,26 @@
+import type { PolicyMatchedBy, PolicyValidationResult, ResolvedPolicyDecision as SharedResolvedPolicyDecision, ResolvedPolicyMatch as SharedResolvedPolicyMatch, ResolvedPolicy as SharedResolvedRuntimePolicy } from '@c15t/schema/types';
+import type { JurisdictionCode as BackendJurisdictionCode } from '../../types';
+export type { PolicyMatchedBy, PolicyValidationResult };
+export type ResolvedRuntimePolicy = SharedResolvedRuntimePolicy;
+export type ResolvedPolicyDecision = SharedResolvedPolicyDecision;
+export type ResolvedPolicyMatch = SharedResolvedPolicyMatch;
+export declare function inspectPolicies(policies: unknown, options?: {
+    iabEnabled?: boolean;
+}): PolicyValidationResult;
+export declare function validatePolicies(policies: unknown, options?: {
+    iabEnabled?: boolean;
+}): void;
+export declare function resolvePolicyDecision(params: {
+    policies?: unknown;
+    countryCode: string | null;
+    regionCode: string | null;
+    jurisdiction?: BackendJurisdictionCode;
+    iabEnabled?: boolean;
+}): Promise<ResolvedPolicyDecision | undefined>;
+export declare function resolvePolicySync(params: {
+    policies?: unknown;
+    countryCode: string | null;
+    regionCode: string | null;
+    jurisdiction?: BackendJurisdictionCode;
+    iabEnabled?: boolean;
+}): ResolvedPolicyMatch | undefined;

package/dist-types/handlers/init/resolve-init.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Shared init payload resolution — used by both the Hono route and the edge handler.
+ *
+ * @packageDocumentation
+ */
+import type { Logger } from '@c15t/logger';
+import type { ResolvedPolicy } from '@c15t/schema/types';
+import type { C15TEdgeOptions } from '../../edge/types';
+/**
+ * Subset of C15TOptions needed by the init resolver.
+ * Derived from {@link C15TEdgeOptions} minus `logger` (passed separately).
+ */
+export type InitResolverOptions = Omit<C15TEdgeOptions, 'logger'>;
+/** The JSON-serializable payload returned by /init. */
+export interface InitPayload {
+    jurisdiction: string;
+    location: {
+        countryCode: string | null;
+        regionCode: string | null;
+    };
+    translations: {
+        translations: unknown;
+        language: string;
+    };
+    branding: string;
+    gvl?: unknown;
+    customVendors?: unknown[];
+    policy?: ResolvedPolicy;
+    policyDecision?: {
+        policyId: string;
+        fingerprint: string;
+        matchedBy: string;
+        country: string | null;
+        region: string | null;
+        jurisdiction: string;
+    };
+    policySnapshotToken?: string;
+    cmpId?: number;
+}
+/**
+ * Resolves the full /init payload from a request and options.
+ * Pure function — no Hono, no database dependency.
+ */
+export declare function resolveInitPayload(request: Request, options: InitResolverOptions, logger?: Logger): Promise<InitPayload>;

package/dist-types/handlers/init/translations.d.ts

@@ -0,0 +1,48 @@
+import { type CompleteTranslations, type Translations } from '@c15t/translations';
+import type { C15TOptions, PolicyConfig } from '../../types';
+interface LoggerLike {
+    warn: (message: string, metadata?: Record<string, unknown>) => void;
+}
+interface TranslationResolutionOptions {
+    i18n?: C15TOptions['i18n'];
+    policyI18n?: PolicyConfig['i18n'];
+    logger?: LoggerLike;
+}
+export declare function listProfiles(options: {
+    customTranslations?: Record<string, Partial<Translations>>;
+    i18n?: C15TOptions['i18n'];
+}): string[];
+export declare function validateMessages(options: {
+    customTranslations?: Record<string, Partial<Translations>>;
+    i18n?: C15TOptions['i18n'];
+    policies?: PolicyConfig[];
+}): {
+    profiles: string[];
+    errors: string[];
+    warnings: string[];
+};
+/**
+ * Gets the translations data for a given language, resolving optional policy
+ * profile/language hints and compatibility aliases.
+ *
+ * Fallback order:
+ * 1) profile + language
+ * 2) profile + fallback language
+ */
+export declare function getTranslationsData(acceptLanguage: string | null, customTranslations?: Record<string, Partial<Translations>>, options?: TranslationResolutionOptions): {
+    translations: CompleteTranslations;
+    language: string;
+};
+/**
+ * Gets the translations for a given language from options.
+ */
+export declare function getTranslations(acceptLanguage: string, options: {
+    customTranslations?: Record<string, Partial<Translations>>;
+    i18n?: C15TOptions['i18n'];
+    policyI18n?: PolicyConfig['i18n'];
+    logger?: LoggerLike;
+}): Promise<{
+    translations: CompleteTranslations;
+    language: string;
+}>;
+export {};

package/dist-types/handlers/legal-document/current.handler.d.ts

@@ -0,0 +1,11 @@
+import type { Context } from 'hono';
+export declare const syncCurrentLegalDocumentHandler: (c: Context) => Promise<Response & import("hono").TypedResponse<{
+    policy: {
+        id: string;
+        type: string;
+        version: string;
+        hash: string;
+        effectiveDate: string;
+        isActive: boolean;
+    };
+}, import("hono/utils/http-status").ContentfulStatusCode, "json">>;

package/dist-types/handlers/legal-document/snapshot.d.ts

@@ -0,0 +1,39 @@
+import { type JWTPayload } from 'jose';
+import type { LegalDocumentPolicyType, LegalDocumentSnapshotOptions } from '../../types';
+export type LegalDocumentSnapshotVerificationFailureReason = 'missing' | 'malformed' | 'expired' | 'invalid';
+export type LegalDocumentSnapshotVerificationResult = {
+    valid: true;
+    payload: LegalDocumentSnapshotPayload;
+} | {
+    valid: false;
+    reason: LegalDocumentSnapshotVerificationFailureReason;
+};
+export interface LegalDocumentSnapshotPayload extends JWTPayload {
+    iss: string;
+    aud: string;
+    sub: string;
+    tenantId?: string;
+    type: LegalDocumentPolicyType;
+    version: string;
+    hash: string;
+    effectiveDate: string;
+    iat: number;
+    exp: number;
+}
+export declare function createLegalDocumentSnapshotToken(params: {
+    options?: LegalDocumentSnapshotOptions;
+    tenantId?: string;
+    type: LegalDocumentPolicyType;
+    version: string;
+    hash: string;
+    effectiveDate: string;
+    ttlSeconds?: number;
+}): Promise<{
+    token: string;
+    payload: LegalDocumentSnapshotPayload;
+} | undefined>;
+export declare function verifyLegalDocumentSnapshotToken(params: {
+    token?: string;
+    options?: LegalDocumentSnapshotOptions;
+    tenantId?: string;
+}): Promise<LegalDocumentSnapshotVerificationResult>;

package/dist-types/handlers/policy/snapshot.d.ts

@@ -0,0 +1,99 @@
+import { type JWTPayload } from 'jose';
+import type { JurisdictionCode, PolicyModel, PolicyScopeMode, PolicySnapshotOptions, PolicyUiMode, PolicyUiSurfaceConfig } from '../../types';
+import type { PolicyMatchedBy } from '../init/policy';
+export type PolicySnapshotVerificationFailureReason = 'missing' | 'malformed' | 'expired' | 'invalid';
+export type PolicySnapshotVerificationResult = {
+    valid: true;
+    payload: PolicySnapshotPayload;
+} | {
+    valid: false;
+    reason: PolicySnapshotVerificationFailureReason;
+};
+export interface PolicySnapshotUiSurface {
+    allowedActions?: PolicyUiSurfaceConfig['allowedActions'];
+    primaryActions?: PolicyUiSurfaceConfig['primaryActions'];
+    layout?: PolicyUiSurfaceConfig['layout'];
+    direction?: PolicyUiSurfaceConfig['direction'];
+    uiProfile?: PolicyUiSurfaceConfig['uiProfile'];
+    scrollLock?: PolicyUiSurfaceConfig['scrollLock'];
+}
+/**
+ * JWT payload for a policy snapshot token.
+ *
+ * @remarks
+ * Fields are intentionally flattened from the nested `ResolvedPolicy` structure
+ * to keep the JWT compact. For example, `scopeMode` maps to
+ * `ResolvedPolicy.consent.scopeMode` and `uiMode` maps to
+ * `ResolvedPolicy.ui.mode`. The post handler reconstructs the nested shape
+ * when verifying the token.
+ */
+export interface PolicySnapshotPayload extends JWTPayload {
+    iss: string;
+    aud: string;
+    sub: string;
+    tenantId?: string;
+    policyId: string;
+    fingerprint: string;
+    matchedBy: PolicyMatchedBy;
+    country: string | null;
+    region: string | null;
+    jurisdiction: JurisdictionCode;
+    language?: string;
+    model: PolicyModel;
+    policyI18n?: {
+        language?: string;
+        messageProfile?: string;
+    };
+    expiryDays?: number;
+    scopeMode?: PolicyScopeMode;
+    uiMode?: PolicyUiMode;
+    bannerUi?: PolicySnapshotUiSurface;
+    dialogUi?: PolicySnapshotUiSurface;
+    categories?: string[];
+    preselectedCategories?: string[];
+    gpc?: boolean;
+    proofConfig?: {
+        storeIp?: boolean;
+        storeUserAgent?: boolean;
+        storeLanguage?: boolean;
+    };
+    iat: number;
+    exp: number;
+}
+export declare function createPolicySnapshotToken(params: {
+    options?: PolicySnapshotOptions;
+    tenantId?: string;
+    policyId: string;
+    fingerprint: string;
+    matchedBy: PolicyMatchedBy;
+    country: string | null;
+    region: string | null;
+    jurisdiction: JurisdictionCode;
+    language?: string;
+    model: PolicyModel;
+    policyI18n?: {
+        language?: string;
+        messageProfile?: string;
+    };
+    expiryDays?: number;
+    scopeMode?: PolicyScopeMode;
+    uiMode?: PolicyUiMode;
+    bannerUi?: PolicySnapshotUiSurface;
+    dialogUi?: PolicySnapshotUiSurface;
+    categories?: string[];
+    preselectedCategories?: string[];
+    gpc?: boolean;
+    proofConfig?: {
+        storeIp?: boolean;
+        storeUserAgent?: boolean;
+        storeLanguage?: boolean;
+    };
+}): Promise<{
+    token: string;
+    payload: PolicySnapshotPayload;
+} | undefined>;
+export declare function verifyPolicySnapshotToken(params: {
+    token?: string;
+    options?: PolicySnapshotOptions;
+    tenantId?: string;
+}): Promise<PolicySnapshotVerificationResult>;

package/{src/handlers/status/index.ts → dist-types/handlers/status/index.d.ts}

@@ -3,5 +3,4 @@
  *
  * @packageDocumentation
  */
-
 export { statusHandler } from './status.handler';

package/{dist → dist-types}/handlers/status/status.handler.d.ts

@@ -23,4 +23,3 @@ export declare const statusHandler: (c: Context) => Promise<Response & import("h
         };
     };
 }, import("hono/utils/http-status").ContentfulStatusCode, "json">>;
-//# sourceMappingURL=status.handler.d.ts.map

package/{dist → dist-types}/handlers/subject/get.handler.d.ts

@@ -14,13 +14,15 @@ export declare const getSubjectHandler: (c: Context) => Promise<Response & impor
     subject: {
         id: string;
         externalId: string | undefined;
-        isIdentified: boolean;
         createdAt: string;
     };
     consents: {
         id: string;
         type: string;
         policyId: string | undefined;
+        policyVersion: string | undefined;
+        policyHash: string | undefined;
+        policyEffectiveDate: string | undefined;
         isLatestPolicy: boolean;
         preferences: {
             [x: string]: boolean;
@@ -29,4 +31,3 @@ export declare const getSubjectHandler: (c: Context) => Promise<Response & impor
     }[];
     isValid: boolean;
 }, import("hono/utils/http-status").ContentfulStatusCode, "json">>;
-//# sourceMappingURL=get.handler.d.ts.map

package/{src/handlers/subject/index.ts → dist-types/handlers/subject/index.d.ts}

@@ -3,7 +3,6 @@
  *
  * @packageDocumentation
  */
-
 export { getSubjectHandler } from './get.handler';
 export { listSubjectsHandler } from './list.handler';
 export { patchSubjectHandler } from './patch.handler';

package/{dist → dist-types}/handlers/subject/list.handler.d.ts

@@ -14,12 +14,14 @@ export declare const listSubjectsHandler: (c: Context) => Promise<Response & imp
     subjects: {
         id: string;
         externalId: string;
-        isIdentified: boolean;
         createdAt: string;
         consents: {
             id: string;
             type: string;
             policyId: string | undefined;
+            policyVersion: string | undefined;
+            policyHash: string | undefined;
+            policyEffectiveDate: string | undefined;
             isLatestPolicy: boolean;
             preferences: {
                 [x: string]: boolean;
@@ -28,4 +30,3 @@ export declare const listSubjectsHandler: (c: Context) => Promise<Response & imp
         }[];
     }[];
 }, import("hono/utils/http-status").ContentfulStatusCode, "json">>;
-//# sourceMappingURL=list.handler.d.ts.map

package/{dist → dist-types}/handlers/subject/patch.handler.d.ts

@@ -16,7 +16,5 @@ export declare const patchSubjectHandler: (c: Context) => Promise<Response & imp
     subject: {
         id: string;
         externalId: string;
-        isIdentified: true;
     };
 }, import("hono/utils/http-status").ContentfulStatusCode, "json">>;
-//# sourceMappingURL=patch.handler.d.ts.map

package/{dist → dist-types}/handlers/subject/post.handler.d.ts

@@ -4,6 +4,15 @@
  * @packageDocumentation
  */
 import type { Context } from 'hono';
+export declare function buildRuntimeDecisionDedupeKey(input: {
+    tenantId?: string;
+    fingerprint: string;
+    matchedBy: string;
+    countryCode: string | null;
+    regionCode: string | null;
+    jurisdiction: string;
+    language?: string;
+}): string;
 /**
  * Handles the creation of a new consent record for a subject.
  *
@@ -19,7 +28,9 @@ export declare const postSubjectHandler: (c: Context) => Promise<Response & impo
     metadata: {
         [x: string]: import("hono/utils/types").JSONValue;
     } | undefined;
+    appliedPreferences: {
+        [x: string]: boolean;
+    } | undefined;
     uiSource: string | undefined;
     givenAt: string;
 }, import("hono/utils/http-status").ContentfulStatusCode, "json">>;
-//# sourceMappingURL=post.handler.d.ts.map

package/{dist → dist-types}/handlers/utils/consent-enrichment.d.ts

@@ -12,6 +12,9 @@ export interface EnrichedConsentItem {
     id: string;
     type: string;
     policyId: string | undefined;
+    policyVersion: string | undefined;
+    policyHash: string | undefined;
+    policyEffectiveDate: Date | undefined;
     isLatestPolicy: boolean;
     preferences: Record<string, boolean> | undefined;
     givenAt: Date;
@@ -49,4 +52,3 @@ export declare function resolveConsentPolicies(consents: Array<{
     policyId: string | null;
 }>, ctx: EnrichmentContext): Promise<ConsentPolicyInfo[]>;
 export {};
-//# sourceMappingURL=consent-enrichment.d.ts.map

package/{dist → dist-types}/init.d.ts

@@ -16,15 +16,12 @@ import type { C15TContext, C15TOptions } from './types';
  *
  * // Then pass telemetry config
  * const instance = c15tInstance({
- *   advanced: {
- *     telemetry: {
- *       enabled: true,
- *       tracer: trace.getTracer('my-app'),
- *       meter: metrics.getMeter('my-app'),
- *     },
+ *   telemetry: {
+ *     enabled: true,
+ *     tracer: trace.getTracer('my-app'),
+ *     meter: metrics.getMeter('my-app'),
  *   },
  * });
  * ```
  */
 export declare const init: (options: C15TOptions) => C15TContext;
-//# sourceMappingURL=init.d.ts.map

package/{dist → dist-types}/middleware/auth/index.d.ts

@@ -4,4 +4,3 @@
  * @packageDocumentation
  */
 export { extractBearerToken, validateApiKey, validateRequestAuth, } from './validate-api-key';
-//# sourceMappingURL=index.d.ts.map

package/{dist → dist-types}/middleware/auth/validate-api-key.d.ts

@@ -46,4 +46,3 @@ export declare function validateApiKey(token: string | null, validKeys: string[]
  * ```
  */
 export declare function validateRequestAuth(headers: Headers | undefined, validKeys: string[] | undefined): boolean;
-//# sourceMappingURL=validate-api-key.d.ts.map

package/{dist → dist-types}/middleware/cors/cors.d.ts

@@ -30,4 +30,3 @@ export interface CorsOptions {
  * ```
  */
 export declare function createCORSOptions(trustedOrigins?: string[] | string): CorsOptions;
-//# sourceMappingURL=cors.d.ts.map

package/{src/middleware/cors/index.ts → dist-types/middleware/cors/index.d.ts}

@@ -24,7 +24,6 @@
  *
  * @packageDocumentation
  */
-
 export { createCORSOptions } from './cors';
 export { isOriginTrusted } from './is-origin-trusted';
 export { processCors } from './process-cors';

package/{dist → dist-types}/middleware/cors/is-origin-trusted.d.ts

@@ -46,4 +46,3 @@ export declare const STRIP_REGEX: RegExp;
  * ```
  */
 export declare function isOriginTrusted(origin: string, trustedDomains: string[], logger?: Logger): boolean;
-//# sourceMappingURL=is-origin-trusted.d.ts.map