@c15t/backend 1.5.0 → 1.6.0

package/dist/v2/core.js

@@ -0,0 +1,2130 @@
+import * as __WEBPACK_EXTERNAL_MODULE__doubletie_logger_91c58a8f__ from "@doubletie/logger";
+import * as __WEBPACK_EXTERNAL_MODULE__orpc_openapi_fetch_89b49e61__ from "@orpc/openapi/fetch";
+import * as __WEBPACK_EXTERNAL_MODULE__orpc_server_0dae8408__ from "@orpc/server";
+import * as __WEBPACK_EXTERNAL_MODULE__orpc_server_plugins_e445fd4f__ from "@orpc/server/plugins";
+import * as __WEBPACK_EXTERNAL_MODULE_defu__ from "defu";
+import * as __WEBPACK_EXTERNAL_MODULE__orpc_openapi_a95cc8e7__ from "@orpc/openapi";
+import * as __WEBPACK_EXTERNAL_MODULE__orpc_zod_716a28d4__ from "@orpc/zod";
+import * as __WEBPACK_EXTERNAL_MODULE__orpc_contract_5a058524__ from "@orpc/contract";
+import * as __WEBPACK_EXTERNAL_MODULE_zod__ from "zod";
+import * as __WEBPACK_EXTERNAL_MODULE_fumadb__ from "fumadb";
+import * as __WEBPACK_EXTERNAL_MODULE_fumadb_schema_96658f6d__ from "fumadb/schema";
+import * as __WEBPACK_EXTERNAL_MODULE_base_x_aeb88370__ from "base-x";
+import * as __WEBPACK_EXTERNAL_MODULE__c15t_translations_cdae900b__ from "@c15t/translations";
+import * as __WEBPACK_EXTERNAL_MODULE__opentelemetry_resources_c7ac8648__ from "@opentelemetry/resources";
+import * as __WEBPACK_EXTERNAL_MODULE__opentelemetry_sdk_node_50b75088__ from "@opentelemetry/sdk-node";
+import * as __WEBPACK_EXTERNAL_MODULE__opentelemetry_sdk_trace_base_5031a705__ from "@opentelemetry/sdk-trace-base";
+import * as __WEBPACK_EXTERNAL_MODULE__opentelemetry_api_87359e78__ from "@opentelemetry/api";
+const WWW_REGEX = /^www\./;
+const PROTOCOL_WWW_REGEX = /^https?:\/\/(www\.)?/;
+const SUPPORTED_METHODS = [
+    'GET',
+    'POST',
+    'PUT',
+    'DELETE',
+    'PATCH',
+    'OPTIONS'
+];
+const SUPPORTED_HEADERS = [
+    'Content-Type',
+    'Authorization',
+    'x-request-id'
+];
+const DEFAULT_CORS_CONFIG = {
+    origin: async (origin)=>await Promise.resolve(origin || '*'),
+    credentials: true,
+    allowHeaders: SUPPORTED_HEADERS,
+    maxAge: 600,
+    methods: SUPPORTED_METHODS
+};
+function createCORSOptions(trustedOrigins) {
+    if (!trustedOrigins) return DEFAULT_CORS_CONFIG;
+    const origins = Array.isArray(trustedOrigins) ? trustedOrigins : [
+        trustedOrigins
+    ];
+    if (0 === origins.length) return DEFAULT_CORS_CONFIG;
+    function normalizeOrigin(origin) {
+        try {
+            if (!origin.includes('://') && !origin.includes(':') && !origin.includes('/')) return origin.toLowerCase();
+            const originWithProtocol = origin.startsWith('http://') || origin.startsWith('https://') || origin.startsWith('ws://') || origin.startsWith('wss://') ? origin : `http://${origin}`;
+            const url = new URL(originWithProtocol);
+            const hostname = url.hostname.replace(WWW_REGEX, '');
+            return `${hostname}${url.port ? `:${url.port}` : ''}`;
+        } catch  {
+            return origin.replace(PROTOCOL_WWW_REGEX, '').replace(WWW_REGEX, '');
+        }
+    }
+    function expandWithWWW(origins) {
+        const expanded = new Set();
+        for (const origin of origins){
+            if ('*' === origin) {
+                expanded.add('*');
+                continue;
+            }
+            const normalized = normalizeOrigin(origin);
+            expanded.add(normalized);
+            if (!normalized.includes('www.')) expanded.add(`www.${normalized}`);
+        }
+        return Array.from(expanded);
+    }
+    const expandedTrusted = expandWithWWW(origins);
+    const returnConfig = {
+        origin: async (origin)=>{
+            if (!origin) return '*';
+            const normalizedOrigin = normalizeOrigin(origin);
+            if (expandedTrusted.includes('*')) return origin;
+            const isTrusted = expandedTrusted.some((trusted)=>{
+                const normalizedTrusted = normalizeOrigin(trusted);
+                if ('localhost' === normalizedTrusted) return 'localhost' === normalizedOrigin || normalizedOrigin.startsWith('localhost:') || '127.0.0.1' === normalizedOrigin || normalizedOrigin.startsWith('127.0.0.1:') || '[::1]' === normalizedOrigin || normalizedOrigin.startsWith('[::1]:');
+                return normalizedTrusted === normalizedOrigin;
+            });
+            return isTrusted ? origin : null;
+        },
+        credentials: true,
+        allowHeaders: SUPPORTED_HEADERS,
+        maxAge: 600,
+        methods: SUPPORTED_METHODS
+    };
+    return returnConfig;
+}
+const STRIP_REGEX = /^(https?:\/\/)|(wss?:\/\/)|(\/+$)|:\d+/g;
+function matchesWildcard(hostname, wildcardPattern, logger) {
+    const wildcardDomain = wildcardPattern.slice(2);
+    const parts = hostname.split('.');
+    const isValid = parts.length > 2 && hostname.endsWith(wildcardDomain);
+    logger?.debug(`Wildcard match result: ${isValid} ${hostname} ends with ${wildcardDomain} ${parts.length > 2} ${hostname.endsWith(wildcardDomain)}`);
+    return isValid;
+}
+function isOriginTrusted(origin, trustedDomains, logger) {
+    try {
+        if (0 === trustedDomains.length) throw new Error('No trusted domains');
+        logger?.debug(`Checking if origin ${origin} is trusted in ${trustedDomains}`);
+        if (trustedDomains.includes('*')) {
+            logger?.debug('Allowing all origins');
+            return true;
+        }
+        const url = new URL(origin);
+        const originHostname = url.hostname.toLowerCase();
+        logger?.debug(`Parsed origin hostname: ${originHostname}`);
+        return trustedDomains.some((domain)=>{
+            if (!domain || '' === domain.trim()) {
+                logger?.debug('Skipping empty domain');
+                return false;
+            }
+            const strippedDomain = domain.replace(STRIP_REGEX, '').toLowerCase();
+            logger?.debug(`Checking against stripped domain: ${strippedDomain}`);
+            if (strippedDomain.startsWith('*.')) return matchesWildcard(originHostname, strippedDomain, logger);
+            const isMatch = originHostname === strippedDomain;
+            logger?.debug(`Exact match result: ${isMatch} ${originHostname} === ${strippedDomain}`);
+            return isMatch;
+        });
+    } catch (error) {
+        logger?.error('Error validating origin:', error);
+        return false;
+    }
+}
+function extractCORSInfo(request, trustedOrigins, logger) {
+    const origin = request.headers.get('origin');
+    if (!origin || !trustedOrigins) return {
+        origin: origin,
+        isTrusted: false
+    };
+    return {
+        origin,
+        isTrusted: isOriginTrusted(origin, trustedOrigins, logger)
+    };
+}
+const processCors = (request, context, trustedOrigins)=>{
+    const { origin, isTrusted } = extractCORSInfo(request, trustedOrigins, context.logger);
+    if (origin) {
+        context.origin = origin;
+        context.trustedOrigin = isTrusted;
+    }
+    return context;
+};
+const version = '1.6.0';
+const createOpenAPIConfig = (options)=>{
+    const basePath = options.basePath || '';
+    return {
+        enabled: true,
+        specPath: `${basePath}/spec.json`,
+        docsPath: `${basePath}/docs`,
+        ...options.advanced?.openapi || {}
+    };
+};
+const createDefaultOpenAPIOptions = (options)=>({
+        info: {
+            title: options.appName || 'c15t API',
+            version: version,
+            description: 'API for consent management'
+        },
+        servers: [
+            {
+                url: options.basePath || '/'
+            }
+        ],
+        security: [
+            {
+                bearerAuth: []
+            }
+        ]
+    });
+const auditLogTable = (0, __WEBPACK_EXTERNAL_MODULE_fumadb_schema_96658f6d__.table)('auditLog', {
+    id: (0, __WEBPACK_EXTERNAL_MODULE_fumadb_schema_96658f6d__.idColumn)('id', 'varchar(255)'),
+    entityType: (0, __WEBPACK_EXTERNAL_MODULE_fumadb_schema_96658f6d__.column)('entityType', 'string'),
+    entityId: (0, __WEBPACK_EXTERNAL_MODULE_fumadb_schema_96658f6d__.column)('entityId', 'string'),
+    actionType: (0, __WEBPACK_EXTERNAL_MODULE_fumadb_schema_96658f6d__.column)('actionType', 'string'),
+    subjectId: (0, __WEBPACK_EXTERNAL_MODULE_fumadb_schema_96658f6d__.column)('subjectId', 'string').nullable(),
+    ipAddress: (0, __WEBPACK_EXTERNAL_MODULE_fumadb_schema_96658f6d__.column)('ipAddress', 'string').nullable(),
+    userAgent: (0, __WEBPACK_EXTERNAL_MODULE_fumadb_schema_96658f6d__.column)('userAgent', 'string').nullable(),
+    changes: (0, __WEBPACK_EXTERNAL_MODULE_fumadb_schema_96658f6d__.column)('changes', 'json').nullable(),
+    metadata: (0, __WEBPACK_EXTERNAL_MODULE_fumadb_schema_96658f6d__.column)('metadata', 'json').nullable(),
+    createdAt: (0, __WEBPACK_EXTERNAL_MODULE_fumadb_schema_96658f6d__.column)('createdAt', 'timestamp').defaultTo$('now'),
+    eventTimezone: (0, __WEBPACK_EXTERNAL_MODULE_fumadb_schema_96658f6d__.column)('eventTimezone', 'string').defaultTo$(()=>'UTC')
+});
+__WEBPACK_EXTERNAL_MODULE_zod__.z.object({
+    id: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+    entityType: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+    entityId: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+    actionType: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+    subjectId: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().optional(),
+    ipAddress: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().optional(),
+    userAgent: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().optional(),
+    changes: __WEBPACK_EXTERNAL_MODULE_zod__.z.record(__WEBPACK_EXTERNAL_MODULE_zod__.z.string(), __WEBPACK_EXTERNAL_MODULE_zod__.z.unknown()).optional(),
+    metadata: __WEBPACK_EXTERNAL_MODULE_zod__.z.record(__WEBPACK_EXTERNAL_MODULE_zod__.z.string(), __WEBPACK_EXTERNAL_MODULE_zod__.z.unknown()).optional(),
+    createdAt: __WEBPACK_EXTERNAL_MODULE_zod__.z.date().prefault(()=>new Date()),
+    eventTimezone: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().prefault('UTC')
+});
+const consentTable = (0, __WEBPACK_EXTERNAL_MODULE_fumadb_schema_96658f6d__.table)('consent', {
+    id: (0, __WEBPACK_EXTERNAL_MODULE_fumadb_schema_96658f6d__.idColumn)('id', 'varchar(255)'),
+    subjectId: (0, __WEBPACK_EXTERNAL_MODULE_fumadb_schema_96658f6d__.column)('subjectId', 'string'),
+    domainId: (0, __WEBPACK_EXTERNAL_MODULE_fumadb_schema_96658f6d__.column)('domainId', 'string'),
+    policyId: (0, __WEBPACK_EXTERNAL_MODULE_fumadb_schema_96658f6d__.column)('policyId', 'string').nullable(),
+    purposeIds: (0, __WEBPACK_EXTERNAL_MODULE_fumadb_schema_96658f6d__.column)('purposeIds', 'json'),
+    metadata: (0, __WEBPACK_EXTERNAL_MODULE_fumadb_schema_96658f6d__.column)('metadata', 'json').nullable(),
+    ipAddress: (0, __WEBPACK_EXTERNAL_MODULE_fumadb_schema_96658f6d__.column)('ipAddress', 'string').nullable(),
+    userAgent: (0, __WEBPACK_EXTERNAL_MODULE_fumadb_schema_96658f6d__.column)('userAgent', 'string').nullable(),
+    status: (0, __WEBPACK_EXTERNAL_MODULE_fumadb_schema_96658f6d__.column)('status', 'string').defaultTo$(()=>'active'),
+    withdrawalReason: (0, __WEBPACK_EXTERNAL_MODULE_fumadb_schema_96658f6d__.column)('withdrawalReason', 'string').nullable(),
+    givenAt: (0, __WEBPACK_EXTERNAL_MODULE_fumadb_schema_96658f6d__.column)('givenAt', 'timestamp').defaultTo$('now'),
+    validUntil: (0, __WEBPACK_EXTERNAL_MODULE_fumadb_schema_96658f6d__.column)('validUntil', 'timestamp').nullable(),
+    isActive: (0, __WEBPACK_EXTERNAL_MODULE_fumadb_schema_96658f6d__.column)('isActive', 'bool').defaultTo$(()=>true)
+});
+const consentStatusSchema = __WEBPACK_EXTERNAL_MODULE_zod__.z["enum"]([
+    'active',
+    'withdrawn',
+    'expired'
+]);
+__WEBPACK_EXTERNAL_MODULE_zod__.z.object({
+    id: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+    subjectId: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+    domainId: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+    purposeIds: __WEBPACK_EXTERNAL_MODULE_zod__.z.array(__WEBPACK_EXTERNAL_MODULE_zod__.z.string()),
+    metadata: __WEBPACK_EXTERNAL_MODULE_zod__.z.record(__WEBPACK_EXTERNAL_MODULE_zod__.z.string(), __WEBPACK_EXTERNAL_MODULE_zod__.z.unknown()).nullish(),
+    policyId: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().optional(),
+    ipAddress: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().nullish(),
+    userAgent: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().nullish(),
+    status: consentStatusSchema.prefault('active'),
+    withdrawalReason: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().nullish(),
+    givenAt: __WEBPACK_EXTERNAL_MODULE_zod__.z.date().prefault(()=>new Date()),
+    validUntil: __WEBPACK_EXTERNAL_MODULE_zod__.z.date().nullish(),
+    isActive: __WEBPACK_EXTERNAL_MODULE_zod__.z.boolean().prefault(true)
+});
+const consentPolicyTable = (0, __WEBPACK_EXTERNAL_MODULE_fumadb_schema_96658f6d__.table)('consentPolicy', {
+    id: (0, __WEBPACK_EXTERNAL_MODULE_fumadb_schema_96658f6d__.idColumn)('id', 'varchar(255)'),
+    version: (0, __WEBPACK_EXTERNAL_MODULE_fumadb_schema_96658f6d__.column)('version', 'string'),
+    type: (0, __WEBPACK_EXTERNAL_MODULE_fumadb_schema_96658f6d__.column)('type', 'string'),
+    name: (0, __WEBPACK_EXTERNAL_MODULE_fumadb_schema_96658f6d__.column)('name', 'string'),
+    effectiveDate: (0, __WEBPACK_EXTERNAL_MODULE_fumadb_schema_96658f6d__.column)('effectiveDate', 'timestamp'),
+    expirationDate: (0, __WEBPACK_EXTERNAL_MODULE_fumadb_schema_96658f6d__.column)('expirationDate', 'timestamp').nullable(),
+    content: (0, __WEBPACK_EXTERNAL_MODULE_fumadb_schema_96658f6d__.column)('content', 'string'),
+    contentHash: (0, __WEBPACK_EXTERNAL_MODULE_fumadb_schema_96658f6d__.column)('contentHash', 'string'),
+    isActive: (0, __WEBPACK_EXTERNAL_MODULE_fumadb_schema_96658f6d__.column)('isActive', 'bool').defaultTo$(()=>true),
+    createdAt: (0, __WEBPACK_EXTERNAL_MODULE_fumadb_schema_96658f6d__.column)('createdAt', 'timestamp').defaultTo$('now')
+});
+const PolicyTypeSchema = __WEBPACK_EXTERNAL_MODULE_zod__.z["enum"]([
+    'cookie_banner',
+    'privacy_policy',
+    'dpa',
+    'terms_and_conditions',
+    'marketing_communications',
+    'age_verification',
+    'other'
+]);
+__WEBPACK_EXTERNAL_MODULE_zod__.z.object({
+    id: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+    version: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+    type: PolicyTypeSchema,
+    name: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+    effectiveDate: __WEBPACK_EXTERNAL_MODULE_zod__.z.date(),
+    expirationDate: __WEBPACK_EXTERNAL_MODULE_zod__.z.date().nullish(),
+    content: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+    contentHash: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+    isActive: __WEBPACK_EXTERNAL_MODULE_zod__.z.boolean().prefault(true),
+    createdAt: __WEBPACK_EXTERNAL_MODULE_zod__.z.date().prefault(()=>new Date())
+});
+const consentPurposeTable = (0, __WEBPACK_EXTERNAL_MODULE_fumadb_schema_96658f6d__.table)('consentPurpose', {
+    id: (0, __WEBPACK_EXTERNAL_MODULE_fumadb_schema_96658f6d__.idColumn)('id', 'varchar(255)'),
+    code: (0, __WEBPACK_EXTERNAL_MODULE_fumadb_schema_96658f6d__.column)('code', 'string'),
+    name: (0, __WEBPACK_EXTERNAL_MODULE_fumadb_schema_96658f6d__.column)('name', 'string'),
+    description: (0, __WEBPACK_EXTERNAL_MODULE_fumadb_schema_96658f6d__.column)("description", 'string'),
+    isEssential: (0, __WEBPACK_EXTERNAL_MODULE_fumadb_schema_96658f6d__.column)('isEssential', 'bool'),
+    dataCategory: (0, __WEBPACK_EXTERNAL_MODULE_fumadb_schema_96658f6d__.column)('dataCategory', 'string').nullable(),
+    legalBasis: (0, __WEBPACK_EXTERNAL_MODULE_fumadb_schema_96658f6d__.column)('legalBasis', 'string').nullable(),
+    isActive: (0, __WEBPACK_EXTERNAL_MODULE_fumadb_schema_96658f6d__.column)('isActive', 'bool').defaultTo$(()=>true),
+    createdAt: (0, __WEBPACK_EXTERNAL_MODULE_fumadb_schema_96658f6d__.column)('createdAt', 'timestamp').defaultTo$('now'),
+    updatedAt: (0, __WEBPACK_EXTERNAL_MODULE_fumadb_schema_96658f6d__.column)('updatedAt', 'timestamp').defaultTo$('now')
+});
+__WEBPACK_EXTERNAL_MODULE_zod__.z.object({
+    id: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+    code: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+    name: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+    description: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+    isEssential: __WEBPACK_EXTERNAL_MODULE_zod__.z.boolean(),
+    dataCategory: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().nullish(),
+    legalBasis: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().nullish(),
+    isActive: __WEBPACK_EXTERNAL_MODULE_zod__.z.boolean().prefault(true),
+    createdAt: __WEBPACK_EXTERNAL_MODULE_zod__.z.date().prefault(()=>new Date()),
+    updatedAt: __WEBPACK_EXTERNAL_MODULE_zod__.z.date().prefault(()=>new Date())
+});
+const consentRecordTable = (0, __WEBPACK_EXTERNAL_MODULE_fumadb_schema_96658f6d__.table)('consentRecord', {
+    id: (0, __WEBPACK_EXTERNAL_MODULE_fumadb_schema_96658f6d__.idColumn)('id', 'varchar(255)'),
+    subjectId: (0, __WEBPACK_EXTERNAL_MODULE_fumadb_schema_96658f6d__.column)('subjectId', 'string'),
+    consentId: (0, __WEBPACK_EXTERNAL_MODULE_fumadb_schema_96658f6d__.column)('consentId', 'string').nullable(),
+    actionType: (0, __WEBPACK_EXTERNAL_MODULE_fumadb_schema_96658f6d__.column)('actionType', 'string'),
+    details: (0, __WEBPACK_EXTERNAL_MODULE_fumadb_schema_96658f6d__.column)('details', 'json').nullable(),
+    createdAt: (0, __WEBPACK_EXTERNAL_MODULE_fumadb_schema_96658f6d__.column)('createdAt', 'timestamp').defaultTo$('now')
+});
+__WEBPACK_EXTERNAL_MODULE_zod__.z.object({
+    id: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+    subjectId: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+    consentId: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().nullish(),
+    actionType: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+    details: __WEBPACK_EXTERNAL_MODULE_zod__.z.record(__WEBPACK_EXTERNAL_MODULE_zod__.z.string(), __WEBPACK_EXTERNAL_MODULE_zod__.z.unknown()).nullish(),
+    createdAt: __WEBPACK_EXTERNAL_MODULE_zod__.z.date().prefault(()=>new Date())
+});
+const domainTable = (0, __WEBPACK_EXTERNAL_MODULE_fumadb_schema_96658f6d__.table)('domain', {
+    id: (0, __WEBPACK_EXTERNAL_MODULE_fumadb_schema_96658f6d__.idColumn)('id', 'varchar(255)'),
+    name: (0, __WEBPACK_EXTERNAL_MODULE_fumadb_schema_96658f6d__.column)('name', 'string').unique(),
+    description: (0, __WEBPACK_EXTERNAL_MODULE_fumadb_schema_96658f6d__.column)("description", 'string').nullable(),
+    allowedOrigins: (0, __WEBPACK_EXTERNAL_MODULE_fumadb_schema_96658f6d__.column)('allowedOrigins', 'json').nullable(),
+    isVerified: (0, __WEBPACK_EXTERNAL_MODULE_fumadb_schema_96658f6d__.column)('isVerified', 'bool').defaultTo$(()=>true),
+    isActive: (0, __WEBPACK_EXTERNAL_MODULE_fumadb_schema_96658f6d__.column)('isActive', 'bool').defaultTo$(()=>true),
+    createdAt: (0, __WEBPACK_EXTERNAL_MODULE_fumadb_schema_96658f6d__.column)('createdAt', 'timestamp').defaultTo$('now'),
+    updatedAt: (0, __WEBPACK_EXTERNAL_MODULE_fumadb_schema_96658f6d__.column)('updatedAt', 'timestamp').defaultTo$('now')
+});
+__WEBPACK_EXTERNAL_MODULE_zod__.z.object({
+    id: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+    name: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+    description: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().nullish(),
+    allowedOrigins: __WEBPACK_EXTERNAL_MODULE_zod__.z.array(__WEBPACK_EXTERNAL_MODULE_zod__.z.string()).nullish(),
+    isVerified: __WEBPACK_EXTERNAL_MODULE_zod__.z.boolean().prefault(true),
+    isActive: __WEBPACK_EXTERNAL_MODULE_zod__.z.boolean().prefault(true),
+    createdAt: __WEBPACK_EXTERNAL_MODULE_zod__.z.date().prefault(()=>new Date()),
+    updatedAt: __WEBPACK_EXTERNAL_MODULE_zod__.z.date().prefault(()=>new Date())
+});
+const subjectTable = (0, __WEBPACK_EXTERNAL_MODULE_fumadb_schema_96658f6d__.table)('subject', {
+    id: (0, __WEBPACK_EXTERNAL_MODULE_fumadb_schema_96658f6d__.idColumn)('id', 'varchar(255)'),
+    isIdentified: (0, __WEBPACK_EXTERNAL_MODULE_fumadb_schema_96658f6d__.column)('isIdentified', 'bool').defaultTo$(()=>false),
+    externalId: (0, __WEBPACK_EXTERNAL_MODULE_fumadb_schema_96658f6d__.column)('externalId', 'string').nullable(),
+    identityProvider: (0, __WEBPACK_EXTERNAL_MODULE_fumadb_schema_96658f6d__.column)('identityProvider', 'string').nullable(),
+    lastIpAddress: (0, __WEBPACK_EXTERNAL_MODULE_fumadb_schema_96658f6d__.column)('lastIpAddress', 'string').nullable(),
+    subjectTimezone: (0, __WEBPACK_EXTERNAL_MODULE_fumadb_schema_96658f6d__.column)('subjectTimezone', 'string').nullable(),
+    createdAt: (0, __WEBPACK_EXTERNAL_MODULE_fumadb_schema_96658f6d__.column)('createdAt', 'timestamp').defaultTo$('now'),
+    updatedAt: (0, __WEBPACK_EXTERNAL_MODULE_fumadb_schema_96658f6d__.column)('updatedAt', 'timestamp').defaultTo$('now')
+});
+__WEBPACK_EXTERNAL_MODULE_zod__.z.object({
+    id: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+    isIdentified: __WEBPACK_EXTERNAL_MODULE_zod__.z.boolean().prefault(false),
+    externalId: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().nullish(),
+    identityProvider: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().nullish(),
+    lastIpAddress: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().optional(),
+    subjectTimezone: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().nullish(),
+    createdAt: __WEBPACK_EXTERNAL_MODULE_zod__.z.date().prefault(()=>new Date()),
+    updatedAt: __WEBPACK_EXTERNAL_MODULE_zod__.z.date().prefault(()=>new Date())
+});
+const v1 = (0, __WEBPACK_EXTERNAL_MODULE_fumadb_schema_96658f6d__.schema)({
+    version: '1.0.0',
+    tables: {
+        subject: subjectTable,
+        domain: domainTable,
+        consentPolicy: consentPolicyTable,
+        consentPurpose: consentPurposeTable,
+        consent: consentTable,
+        auditLog: auditLogTable,
+        consentRecord: consentRecordTable
+    },
+    relations: {
+        subject: ({ many })=>({
+                consents: many('consent'),
+                consentRecords: many('consentRecord'),
+                auditLogs: many('auditLog')
+            }),
+        domain: ({ many })=>({
+                consents: many('consent')
+            }),
+        consentPolicy: ({ many })=>({
+                consents: many('consent')
+            }),
+        consentPurpose: ()=>({}),
+        consent: ({ one, many })=>({
+                subject: one('subject', [
+                    'subjectId',
+                    'id'
+                ]).foreignKey(),
+                domain: one('domain', [
+                    'domainId',
+                    'id'
+                ]).foreignKey(),
+                policy: one('consentPolicy', [
+                    'policyId',
+                    'id'
+                ]).foreignKey(),
+                consentRecords: many('consentRecord')
+            }),
+        consentRecord: ({ one })=>({
+                subject: one('subject', [
+                    'subjectId',
+                    'id'
+                ]).foreignKey(),
+                consent: one('consent', [
+                    'consentId',
+                    'id'
+                ]).foreignKey()
+            }),
+        auditLog: ({ one })=>({
+                subject: one('subject', [
+                    'subjectId',
+                    'id'
+                ]).foreignKey()
+            })
+    }
+});
+const DB = (0, __WEBPACK_EXTERNAL_MODULE_fumadb__.fumadb)({
+    namespace: 'c15t',
+    schemas: [
+        v1
+    ]
+});
+const baseConsentSchema = __WEBPACK_EXTERNAL_MODULE_zod__.z.object({
+    subjectId: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().optional(),
+    externalSubjectId: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().optional(),
+    domain: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+    type: PolicyTypeSchema,
+    metadata: __WEBPACK_EXTERNAL_MODULE_zod__.z.record(__WEBPACK_EXTERNAL_MODULE_zod__.z.string(), __WEBPACK_EXTERNAL_MODULE_zod__.z.unknown()).optional()
+});
+const cookieBannerSchema = baseConsentSchema.extend({
+    type: __WEBPACK_EXTERNAL_MODULE_zod__.z.literal('cookie_banner'),
+    preferences: __WEBPACK_EXTERNAL_MODULE_zod__.z.record(__WEBPACK_EXTERNAL_MODULE_zod__.z.string(), __WEBPACK_EXTERNAL_MODULE_zod__.z.boolean())
+});
+const policyBasedSchema = baseConsentSchema.extend({
+    type: __WEBPACK_EXTERNAL_MODULE_zod__.z["enum"]([
+        'privacy_policy',
+        'dpa',
+        'terms_and_conditions'
+    ]),
+    policyId: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().optional(),
+    preferences: __WEBPACK_EXTERNAL_MODULE_zod__.z.record(__WEBPACK_EXTERNAL_MODULE_zod__.z.string(), __WEBPACK_EXTERNAL_MODULE_zod__.z.boolean()).optional()
+});
+const otherConsentSchema = baseConsentSchema.extend({
+    type: __WEBPACK_EXTERNAL_MODULE_zod__.z["enum"]([
+        'marketing_communications',
+        'age_verification',
+        'other'
+    ]),
+    preferences: __WEBPACK_EXTERNAL_MODULE_zod__.z.record(__WEBPACK_EXTERNAL_MODULE_zod__.z.string(), __WEBPACK_EXTERNAL_MODULE_zod__.z.boolean()).optional()
+});
+const postConsentContract = __WEBPACK_EXTERNAL_MODULE__orpc_contract_5a058524__.oc.route({
+    method: 'POST',
+    path: '/consent/set',
+    description: `Records a user's consent preferences and creates necessary consent records.
+This endpoint handles various types of consent submissions:
+
+1. Cookie Banner Consent:
+   - Records granular cookie preferences
+   - Supports multiple consent purposes
+   - Creates audit trail for compliance
+
+2. Policy-Based Consent:
+   - Privacy Policy acceptance
+   - Data Processing Agreement (DPA) consent
+   - Terms and Conditions acceptance
+   - Links consent to specific policy versions
+
+3. Other Consent Types:
+   - Marketing communications preferences
+   - Age verification consent
+   - Custom consent types
+
+The endpoint performs the following operations:
+- Creates or retrieves subject records
+- Validates domain and policy information
+- Creates consent records with audit trails
+- Records consent purposes and preferences
+- Generates audit logs for compliance
+
+Use this endpoint to record user consent and maintain a compliant consent management system.`,
+    tags: [
+        'consent',
+        'cookie-banner'
+    ]
+}).errors({
+    INPUT_VALIDATION_FAILED: {
+        status: 422,
+        data: __WEBPACK_EXTERNAL_MODULE_zod__.z.object({
+            formErrors: __WEBPACK_EXTERNAL_MODULE_zod__.z.array(__WEBPACK_EXTERNAL_MODULE_zod__.z.string()),
+            fieldErrors: __WEBPACK_EXTERNAL_MODULE_zod__.z.record(__WEBPACK_EXTERNAL_MODULE_zod__.z.string(), __WEBPACK_EXTERNAL_MODULE_zod__.z.array(__WEBPACK_EXTERNAL_MODULE_zod__.z.string()))
+        }),
+        error: 'Invalid input parameters'
+    },
+    SUBJECT_CREATION_FAILED: {
+        status: 400,
+        data: __WEBPACK_EXTERNAL_MODULE_zod__.z.object({
+            subjectId: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().optional(),
+            externalSubjectId: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().optional()
+        }),
+        error: 'Failed to create or find subject'
+    },
+    DOMAIN_CREATION_FAILED: {
+        status: 500,
+        data: __WEBPACK_EXTERNAL_MODULE_zod__.z.object({
+            domain: __WEBPACK_EXTERNAL_MODULE_zod__.z.string()
+        }),
+        error: 'Failed to create or find domain'
+    },
+    POLICY_NOT_FOUND: {
+        status: 404,
+        data: __WEBPACK_EXTERNAL_MODULE_zod__.z.object({
+            policyId: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+            type: __WEBPACK_EXTERNAL_MODULE_zod__.z.string()
+        }),
+        error: 'Policy not found'
+    },
+    POLICY_INACTIVE: {
+        status: 409,
+        data: __WEBPACK_EXTERNAL_MODULE_zod__.z.object({
+            policyId: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+            type: __WEBPACK_EXTERNAL_MODULE_zod__.z.string()
+        }),
+        error: 'Policy is not active'
+    },
+    POLICY_CREATION_FAILED: {
+        status: 500,
+        data: __WEBPACK_EXTERNAL_MODULE_zod__.z.object({
+            type: __WEBPACK_EXTERNAL_MODULE_zod__.z.string()
+        }),
+        error: 'Failed to create or find policy'
+    },
+    PURPOSE_CREATION_FAILED: {
+        status: 500,
+        data: __WEBPACK_EXTERNAL_MODULE_zod__.z.object({
+            purposeCode: __WEBPACK_EXTERNAL_MODULE_zod__.z.string()
+        }),
+        error: 'Failed to create consent purpose'
+    },
+    CONSENT_CREATION_FAILED: {
+        status: 500,
+        data: __WEBPACK_EXTERNAL_MODULE_zod__.z.object({
+            subjectId: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+            domain: __WEBPACK_EXTERNAL_MODULE_zod__.z.string()
+        }),
+        error: 'Failed to create consent record'
+    }
+}).input(__WEBPACK_EXTERNAL_MODULE_zod__.z.discriminatedUnion('type', [
+    cookieBannerSchema,
+    policyBasedSchema,
+    otherConsentSchema
+])).output(__WEBPACK_EXTERNAL_MODULE_zod__.z.object({
+    id: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+    subjectId: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().optional(),
+    externalSubjectId: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().optional(),
+    domainId: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+    domain: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+    type: PolicyTypeSchema,
+    status: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+    recordId: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+    metadata: __WEBPACK_EXTERNAL_MODULE_zod__.z.record(__WEBPACK_EXTERNAL_MODULE_zod__.z.string(), __WEBPACK_EXTERNAL_MODULE_zod__.z.unknown()).optional(),
+    givenAt: __WEBPACK_EXTERNAL_MODULE_zod__.z.date()
+}));
+const types_branding = [
+    'c15t',
+    'consent',
+    'none'
+];
+const JurisdictionMessages = {
+    GDPR: 'GDPR or equivalent regulations require a cookie banner.',
+    CH: 'Switzerland requires similar data protection measures.',
+    BR: "Brazil's LGPD requires consent for cookies.",
+    PIPEDA: 'PIPEDA requires consent for data collection.',
+    AU: "Australia's Privacy Act mandates transparency about data collection.",
+    APPI: "Japan's APPI requires consent for data collection.",
+    PIPA: "South Korea's PIPA requires consent for data collection.",
+    NONE: 'No specific requirements'
+};
+const JurisdictionCodeSchema = __WEBPACK_EXTERNAL_MODULE_zod__.z["enum"]([
+    'GDPR',
+    'CH',
+    'BR',
+    'PIPEDA',
+    'AU',
+    'APPI',
+    'PIPA',
+    'NONE'
+]);
+const JurisdictionInfoSchema = __WEBPACK_EXTERNAL_MODULE_zod__.z.object({
+    code: JurisdictionCodeSchema,
+    message: __WEBPACK_EXTERNAL_MODULE_zod__.z.string()
+});
+const TitleDescriptionSchema = __WEBPACK_EXTERNAL_MODULE_zod__.z.object({
+    title: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+    description: __WEBPACK_EXTERNAL_MODULE_zod__.z.string()
+});
+const TranslationsSchema = __WEBPACK_EXTERNAL_MODULE_zod__.z.object({
+    common: __WEBPACK_EXTERNAL_MODULE_zod__.z.object({
+        acceptAll: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+        rejectAll: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+        customize: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+        save: __WEBPACK_EXTERNAL_MODULE_zod__.z.string()
+    }),
+    cookieBanner: TitleDescriptionSchema,
+    consentManagerDialog: TitleDescriptionSchema,
+    consentTypes: __WEBPACK_EXTERNAL_MODULE_zod__.z.object({
+        experience: TitleDescriptionSchema,
+        functionality: TitleDescriptionSchema,
+        marketing: TitleDescriptionSchema,
+        measurement: TitleDescriptionSchema,
+        necessary: TitleDescriptionSchema
+    })
+});
+const showConsentBannerContract = __WEBPACK_EXTERNAL_MODULE__orpc_contract_5a058524__.oc.route({
+    method: 'GET',
+    path: '/show-consent-banner',
+    description: `Determines if a user should see a consent banner based on their location and applicable privacy regulations.
+This endpoint performs the following checks:
+
+1. Detects the user's location using various header information:
+   - Cloudflare country headers
+   - Vercel IP country headers
+   - AWS CloudFront headers
+   - Custom country code headers
+
+2. Determines the applicable jurisdiction based on the location:
+   - GDPR (EU/EEA/UK)
+   - Swiss Data Protection Act
+   - LGPD (Brazil)
+   - PIPEDA (Canada)
+   - Australian Privacy Principles
+   - APPI (Japan)
+   - PIPA (South Korea)
+
+3. Returns detailed information about:
+   - Whether to show the consent banner
+   - The applicable jurisdiction and its requirements
+   - The user's detected location (country and region)
+
+Use this endpoint to implement geo-targeted consent banners and ensure compliance with regional privacy regulations.`,
+    tags: [
+        'cookie-banner'
+    ]
+}).output(__WEBPACK_EXTERNAL_MODULE_zod__.z.object({
+    showConsentBanner: __WEBPACK_EXTERNAL_MODULE_zod__.z.boolean(),
+    jurisdiction: JurisdictionInfoSchema,
+    location: __WEBPACK_EXTERNAL_MODULE_zod__.z.object({
+        countryCode: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().nullable(),
+        regionCode: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().nullable()
+    }),
+    translations: __WEBPACK_EXTERNAL_MODULE_zod__.z.object({
+        language: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+        translations: TranslationsSchema
+    }),
+    branding: __WEBPACK_EXTERNAL_MODULE_zod__.z["enum"](types_branding)
+}));
+const verifyConsentInputSchema = __WEBPACK_EXTERNAL_MODULE_zod__.z.strictObject({
+    subjectId: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().optional(),
+    externalSubjectId: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().optional(),
+    domain: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+    type: PolicyTypeSchema,
+    policyId: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().optional(),
+    preferences: __WEBPACK_EXTERNAL_MODULE_zod__.z.array(__WEBPACK_EXTERNAL_MODULE_zod__.z.string()).optional()
+});
+const verify_contract_consentSchema = __WEBPACK_EXTERNAL_MODULE_zod__.z.looseObject({
+    id: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+    purposeIds: __WEBPACK_EXTERNAL_MODULE_zod__.z.array(__WEBPACK_EXTERNAL_MODULE_zod__.z.string())
+});
+const verifyConsentContract = __WEBPACK_EXTERNAL_MODULE__orpc_contract_5a058524__.oc.route({
+    method: 'POST',
+    path: '/consent/verify',
+    description: `Verifies if a user has given valid consent for a specific policy and domain.
+This endpoint performs comprehensive consent verification by:
+
+1. Validating the subject's identity (using subjectId or externalSubjectId)
+2. Verifying the domain's existence and validity
+3. Checking if the specified policy exists and is active
+4. Validating that all required purposes have been consented to
+5. Ensuring the consent record is current and valid
+
+The endpoint supports different types of consent verification:
+- Cookie banner consent verification
+- Privacy policy consent verification
+- Terms and conditions verification
+- Marketing communications consent verification
+- Age verification
+- Custom consent types
+
+Use this endpoint to ensure compliance with privacy regulations and to verify user consent before processing personal data.`,
+    tags: [
+        'consent'
+    ]
+}).errors({
+    INPUT_VALIDATION_FAILED: {
+        status: 422,
+        data: __WEBPACK_EXTERNAL_MODULE_zod__.z.object({
+            formErrors: __WEBPACK_EXTERNAL_MODULE_zod__.z.array(__WEBPACK_EXTERNAL_MODULE_zod__.z.string()),
+            fieldErrors: __WEBPACK_EXTERNAL_MODULE_zod__.z.record(__WEBPACK_EXTERNAL_MODULE_zod__.z.string(), __WEBPACK_EXTERNAL_MODULE_zod__.z.array(__WEBPACK_EXTERNAL_MODULE_zod__.z.string()).optional())
+        }),
+        error: 'Invalid input parameters'
+    },
+    SUBJECT_NOT_FOUND: {
+        status: 404,
+        data: __WEBPACK_EXTERNAL_MODULE_zod__.z.object({
+            subjectId: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().optional(),
+            externalSubjectId: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().optional()
+        }),
+        error: 'Subject not found'
+    },
+    DOMAIN_NOT_FOUND: {
+        status: 404,
+        data: __WEBPACK_EXTERNAL_MODULE_zod__.z.object({
+            domain: __WEBPACK_EXTERNAL_MODULE_zod__.z.string()
+        }),
+        error: 'Domain not found'
+    },
+    POLICY_NOT_FOUND: {
+        status: 404,
+        data: __WEBPACK_EXTERNAL_MODULE_zod__.z.object({
+            policyId: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+            type: __WEBPACK_EXTERNAL_MODULE_zod__.z.string()
+        }),
+        error: 'Policy not found or invalid'
+    },
+    PURPOSES_NOT_FOUND: {
+        status: 404,
+        data: __WEBPACK_EXTERNAL_MODULE_zod__.z.object({
+            preferences: __WEBPACK_EXTERNAL_MODULE_zod__.z.array(__WEBPACK_EXTERNAL_MODULE_zod__.z.string()),
+            foundPurposes: __WEBPACK_EXTERNAL_MODULE_zod__.z.array(__WEBPACK_EXTERNAL_MODULE_zod__.z.string())
+        }),
+        error: 'Could not find all specified purposes'
+    },
+    COOKIE_BANNER_PREFERENCES_REQUIRED: {
+        status: 400,
+        data: __WEBPACK_EXTERNAL_MODULE_zod__.z.object({
+            type: __WEBPACK_EXTERNAL_MODULE_zod__.z.literal('cookie_banner')
+        }),
+        error: 'Preferences are required for cookie banner consent'
+    },
+    NO_CONSENT_FOUND: {
+        status: 404,
+        data: __WEBPACK_EXTERNAL_MODULE_zod__.z.object({
+            policyId: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+            subjectId: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+            domainId: __WEBPACK_EXTERNAL_MODULE_zod__.z.string()
+        }),
+        error: 'No consent found for the given policy'
+    }
+}).input(verifyConsentInputSchema).output(__WEBPACK_EXTERNAL_MODULE_zod__.z.object({
+    isValid: __WEBPACK_EXTERNAL_MODULE_zod__.z.boolean(),
+    reasons: __WEBPACK_EXTERNAL_MODULE_zod__.z.array(__WEBPACK_EXTERNAL_MODULE_zod__.z.string()).optional(),
+    consent: verify_contract_consentSchema.optional()
+}));
+const consentContracts = {
+    post: postConsentContract,
+    showBanner: showConsentBannerContract,
+    verify: verifyConsentContract
+};
+const statusContract = __WEBPACK_EXTERNAL_MODULE__orpc_contract_5a058524__.oc.route({
+    method: 'GET',
+    path: '/status',
+    description: `Returns the current operational status and health metrics of the service.
+This endpoint provides real-time information about:
+- Overall service status (ok/error)
+- Current API version
+- Server timestamp
+- Storage system status and availability
+- Client information (IP, User Agent, Region)
+
+Use this endpoint for health checks, monitoring, and service status verification.`,
+    tags: [
+        'meta'
+    ]
+}).output(__WEBPACK_EXTERNAL_MODULE_zod__.z.object({
+    status: __WEBPACK_EXTERNAL_MODULE_zod__.z["enum"]([
+        'ok',
+        'error'
+    ]),
+    version: __WEBPACK_EXTERNAL_MODULE_zod__.z.string(),
+    timestamp: __WEBPACK_EXTERNAL_MODULE_zod__.z.date(),
+    client: __WEBPACK_EXTERNAL_MODULE_zod__.z.object({
+        ip: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().nullable(),
+        userAgent: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().nullable(),
+        region: __WEBPACK_EXTERNAL_MODULE_zod__.z.object({
+            countryCode: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().nullable(),
+            regionCode: __WEBPACK_EXTERNAL_MODULE_zod__.z.string().nullable()
+        })
+    })
+}));
+const metaContracts = {
+    status: statusContract
+};
+const contracts_config = {
+    consent: consentContracts,
+    meta: metaContracts
+};
+const os = (0, __WEBPACK_EXTERNAL_MODULE__orpc_server_0dae8408__.implement)(contracts_config);
+const prefixes = {
+    auditLog: 'log',
+    consent: 'cns',
+    consentPolicy: 'pol',
+    consentPurpose: 'pur',
+    consentRecord: 'rec',
+    domain: 'dom',
+    subject: 'sub'
+};
+const b58 = (0, __WEBPACK_EXTERNAL_MODULE_base_x_aeb88370__["default"])('123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz');
+function generateId(model) {
+    const buf = crypto.getRandomValues(new Uint8Array(20));
+    const prefix = prefixes[model];
+    const EPOCH_TIMESTAMP = 1700000000000;
+    const t = Date.now() - EPOCH_TIMESTAMP;
+    const high = Math.floor(t / 0x100000000);
+    const low = t >>> 0;
+    buf[0] = high >>> 24 & 255;
+    buf[1] = high >>> 16 & 255;
+    buf[2] = high >>> 8 & 255;
+    buf[3] = 255 & high;
+    buf[4] = low >>> 24 & 255;
+    buf[5] = low >>> 16 & 255;
+    buf[6] = low >>> 8 & 255;
+    buf[7] = 255 & low;
+    return `${prefix}_${b58.encode(buf)}`;
+}
+async function generateUniqueId(db, model, ctx, options = {}) {
+    const { maxRetries = 10, attempt = 0, baseDelay = 5 } = options;
+    if (attempt >= maxRetries) {
+        const error = new Error(`Failed to generate unique ID for ${model} after ${maxRetries} attempts`);
+        ctx?.logger?.error?.('ID generation failed', {
+            model,
+            maxRetries
+        });
+        throw error;
+    }
+    const id = generateId(model);
+    try {
+        const existing = await db.findFirst(model, {
+            where: (b)=>b('id', '=', id)
+        });
+        if (existing) {
+            ctx?.logger?.debug?.('ID conflict detected', {
+                id,
+                model,
+                attempt: attempt + 1,
+                maxRetries
+            });
+            const delay = Math.min(baseDelay * 2 ** attempt, 1000);
+            await new Promise((resolve)=>setTimeout(resolve, delay));
+            return generateUniqueId(db, model, ctx, {
+                maxRetries,
+                attempt: attempt + 1,
+                baseDelay
+            });
+        }
+        return id;
+    } catch (error) {
+        ctx?.logger?.error?.('Error checking ID uniqueness', {
+            error: error.message,
+            model,
+            attempt
+        });
+        if (attempt < maxRetries - 1) {
+            const delay = Math.min(baseDelay * 2 ** attempt, 2000);
+            await new Promise((resolve)=>setTimeout(resolve, delay));
+            return generateUniqueId(db, model, ctx, {
+                maxRetries,
+                attempt: attempt + 1,
+                baseDelay
+            });
+        }
+        throw error;
+    }
+}
+const postConsent = os.consent.post.handler(async ({ input, context })=>{
+    const typedContext = context;
+    const logger = typedContext.logger;
+    logger.info('Handling post-consent request');
+    const { db, registry } = typedContext;
+    const { type, subjectId, externalSubjectId, domain, metadata, preferences } = input;
+    logger.debug('Request parameters', {
+        type,
+        subjectId,
+        externalSubjectId,
+        domain
+    });
+    try {
+        const subject = await registry.findOrCreateSubject({
+            subjectId,
+            externalSubjectId,
+            ipAddress: typedContext.ipAddress
+        });
+        if (!subject) throw new __WEBPACK_EXTERNAL_MODULE__orpc_server_0dae8408__.ORPCError('SUBJECT_CREATION_FAILED', {
+            data: {
+                subjectId,
+                externalSubjectId
+            }
+        });
+        logger.debug('Subject found/created', {
+            subjectId: subject.id
+        });
+        const domainRecord = await typedContext.registry.findOrCreateDomain(domain);
+        if (!domainRecord) throw new __WEBPACK_EXTERNAL_MODULE__orpc_server_0dae8408__.ORPCError('DOMAIN_CREATION_FAILED', {
+            data: {
+                domain
+            }
+        });
+        let policyId;
+        let purposeIds = [];
+        if ('policyId' in input && input.policyId) {
+            policyId = input.policyId;
+            const policy = await typedContext.registry.findConsentPolicyById(policyId);
+            if (!policy) throw new __WEBPACK_EXTERNAL_MODULE__orpc_server_0dae8408__.ORPCError('POLICY_NOT_FOUND', {
+                data: {
+                    policyId,
+                    type
+                }
+            });
+            if (!policy.isActive) throw new __WEBPACK_EXTERNAL_MODULE__orpc_server_0dae8408__.ORPCError('POLICY_INACTIVE', {
+                data: {
+                    policyId,
+                    type
+                }
+            });
+        } else {
+            const policy = await typedContext.registry.findOrCreatePolicy(type);
+            if (!policy) throw new __WEBPACK_EXTERNAL_MODULE__orpc_server_0dae8408__.ORPCError('POLICY_CREATION_FAILED', {
+                data: {
+                    type
+                }
+            });
+            policyId = policy.id;
+        }
+        if (preferences) {
+            const consentedPurposes = Object.entries(preferences).filter(([_, isConsented])=>isConsented).map(([purposeCode])=>purposeCode);
+            logger.debug('Consented purposes', {
+                consentedPurposes
+            });
+            const purposesRaw = await Promise.all(consentedPurposes.map((purposeCode)=>typedContext.registry.findOrCreateConsentPurposeByCode(purposeCode)));
+            const purposes = purposesRaw.map((purpose)=>purpose?.id);
+            logger.debug('Purposes: ', {
+                purposes
+            });
+            purposeIds = purposes;
+        }
+        const result = await db.transaction(async (tx)=>{
+            logger.debug('Creating consent record', {
+                subjectId: subject.id,
+                domainId: domainRecord.id,
+                policyId,
+                purposeIds
+            });
+            const consentRecord = await tx.create('consent', {
+                id: await generateUniqueId(tx, 'consent', typedContext),
+                subjectId: subject.id,
+                domainId: domainRecord.id,
+                policyId,
+                purposeIds: {
+                    json: purposeIds
+                },
+                status: 'active',
+                isActive: true,
+                ipAddress: typedContext.ipAddress || null,
+                userAgent: typedContext.userAgent || null
+            });
+            logger.debug('Created consent', {
+                consentRecord: consentRecord.id
+            });
+            logger.debug('Creating consentRecord entry', {
+                subjectId: subject.id,
+                consentId: consentRecord.id,
+                actionType: 'consent_given',
+                details: metadata
+            });
+            const record = await tx.create('consentRecord', {
+                id: await generateUniqueId(tx, 'consentRecord', typedContext),
+                subjectId: subject.id,
+                consentId: consentRecord.id,
+                actionType: 'consent_given',
+                details: metadata
+            });
+            logger.debug('Created record entry', {
+                record: record.id
+            });
+            logger.debug('Creating audit log', {
+                subjectId: subject.id,
+                entityType: 'consent',
+                entityId: consentRecord.id,
+                actionType: 'consent_given',
+                metadata: metadata
+            });
+            await tx.create('auditLog', {
+                id: await generateUniqueId(tx, 'auditLog', typedContext),
+                subjectId: subject.id,
+                entityType: 'consent',
+                entityId: consentRecord.id,
+                actionType: 'consent_given',
+                metadata: {
+                    consentId: consentRecord.id,
+                    type
+                },
+                ipAddress: typedContext.ipAddress || null,
+                userAgent: typedContext.userAgent || null,
+                eventTimezone: 'UTC'
+            });
+            logger.debug('Created audit log');
+            if (!consentRecord || !record) throw new __WEBPACK_EXTERNAL_MODULE__orpc_server_0dae8408__.ORPCError('CONSENT_CREATION_FAILED', {
+                data: {
+                    subjectId: subject.id,
+                    domain
+                }
+            });
+            return {
+                consent: consentRecord,
+                record
+            };
+        });
+        return {
+            id: result.consent.id,
+            subjectId: subject.id,
+            externalSubjectId: subject.externalId ?? void 0,
+            domainId: domainRecord.id,
+            domain: domainRecord.name,
+            type,
+            status: result.consent.status,
+            recordId: result.record.id,
+            metadata,
+            givenAt: result.consent.givenAt
+        };
+    } catch (error) {
+        logger.error('Error in post-consent handler', {
+            error: error instanceof Error ? error.message : String(error),
+            errorType: error instanceof Error ? error.constructor.name : typeof error
+        });
+        if (error instanceof __WEBPACK_EXTERNAL_MODULE__orpc_server_0dae8408__.ORPCError) throw error;
+        throw new __WEBPACK_EXTERNAL_MODULE__orpc_server_0dae8408__.ORPCError('INTERNAL_SERVER_ERROR', {
+            message: error instanceof Error ? error.message : String(error)
+        });
+    }
+});
+function checkJurisdiction(countryCode) {
+    const jurisdictions = {
+        EU: new Set([
+            'AT',
+            'BE',
+            'BG',
+            'HR',
+            'CY',
+            'CZ',
+            'DK',
+            'EE',
+            'FI',
+            'FR',
+            'DE',
+            'GR',
+            'HU',
+            'IE',
+            'IT',
+            'LV',
+            'LT',
+            'LU',
+            'MT',
+            'NL',
+            'PL',
+            'PT',
+            'RO',
+            'SK',
+            'SI',
+            'ES',
+            'SE'
+        ]),
+        EEA: new Set([
+            'IS',
+            'NO',
+            'LI'
+        ]),
+        UK: new Set([
+            'GB'
+        ]),
+        CH: new Set([
+            'CH'
+        ]),
+        BR: new Set([
+            'BR'
+        ]),
+        CA: new Set([
+            'CA'
+        ]),
+        AU: new Set([
+            'AU'
+        ]),
+        JP: new Set([
+            'JP'
+        ]),
+        KR: new Set([
+            'KR'
+        ])
+    };
+    let showConsentBanner = true;
+    let jurisdictionCode = 'NONE';
+    if (countryCode) {
+        const normalizedCountryCode = countryCode.toUpperCase();
+        showConsentBanner = false;
+        const jurisdictionMap = [
+            {
+                sets: [
+                    jurisdictions.EU,
+                    jurisdictions.EEA,
+                    jurisdictions.UK
+                ],
+                code: 'GDPR'
+            },
+            {
+                sets: [
+                    jurisdictions.CH
+                ],
+                code: 'CH'
+            },
+            {
+                sets: [
+                    jurisdictions.BR
+                ],
+                code: 'BR'
+            },
+            {
+                sets: [
+                    jurisdictions.CA
+                ],
+                code: 'PIPEDA'
+            },
+            {
+                sets: [
+                    jurisdictions.AU
+                ],
+                code: 'AU'
+            },
+            {
+                sets: [
+                    jurisdictions.JP
+                ],
+                code: 'APPI'
+            },
+            {
+                sets: [
+                    jurisdictions.KR
+                ],
+                code: 'PIPA'
+            }
+        ];
+        for (const { sets, code } of jurisdictionMap)if (sets.some((set)=>set.has(normalizedCountryCode))) {
+            jurisdictionCode = code;
+            showConsentBanner = true;
+            break;
+        }
+    }
+    const message = JurisdictionMessages[jurisdictionCode];
+    return {
+        showConsentBanner,
+        jurisdictionCode,
+        message
+    };
+}
+function isSupportedBaseLanguage(lang) {
+    return lang in __WEBPACK_EXTERNAL_MODULE__c15t_translations_cdae900b__.baseTranslations;
+}
+function getPreferredLanguage(acceptLanguage, supportedLanguages) {
+    if (!acceptLanguage) return 'en';
+    const primaryLang = acceptLanguage.split(',')[0]?.split(';')[0]?.split('-')[0]?.toLowerCase();
+    if (primaryLang && supportedLanguages.includes(primaryLang)) return primaryLang;
+    return 'en';
+}
+function getTranslations(acceptLanguage, customTranslations) {
+    const supportedDefaultLanguages = Object.keys(__WEBPACK_EXTERNAL_MODULE__c15t_translations_cdae900b__.baseTranslations);
+    const supportedCustomLanguages = Object.keys(customTranslations || {});
+    const supportedLanguages = [
+        ...supportedDefaultLanguages,
+        ...supportedCustomLanguages
+    ];
+    const preferredLanguage = getPreferredLanguage(acceptLanguage, supportedLanguages);
+    const base = isSupportedBaseLanguage(preferredLanguage) ? __WEBPACK_EXTERNAL_MODULE__c15t_translations_cdae900b__.baseTranslations[preferredLanguage] : __WEBPACK_EXTERNAL_MODULE__c15t_translations_cdae900b__.baseTranslations.en;
+    const custom = supportedCustomLanguages.includes(preferredLanguage) ? customTranslations?.[preferredLanguage] : {};
+    const translations = custom ? (0, __WEBPACK_EXTERNAL_MODULE__c15t_translations_cdae900b__.deepMergeTranslations)(base, custom) : base;
+    return {
+        translations: translations,
+        language: preferredLanguage
+    };
+}
+function getHeaders(headers) {
+    if (!headers) return {
+        countryCode: null,
+        regionCode: null,
+        acceptLanguage: null
+    };
+    const normalizeHeader = (value)=>{
+        if (!value) return null;
+        return Array.isArray(value) ? value[0] ?? null : value;
+    };
+    const countryCode = normalizeHeader(headers.get('x-c15t-country')) ?? normalizeHeader(headers.get('cf-ipcountry')) ?? normalizeHeader(headers.get('x-vercel-ip-country')) ?? normalizeHeader(headers.get('x-amz-cf-ipcountry')) ?? normalizeHeader(headers.get('x-country-code'));
+    const regionCode = normalizeHeader(headers.get('x-c15t-region')) ?? normalizeHeader(headers.get('x-vercel-ip-country-region')) ?? normalizeHeader(headers.get('x-region-code'));
+    const acceptLanguage = normalizeHeader(headers.get('accept-language'));
+    return {
+        countryCode,
+        regionCode,
+        acceptLanguage
+    };
+}
+function buildResponse({ shouldShowBanner, jurisdiction, location, acceptLanguage, customTranslations, branding = 'c15t' }) {
+    return {
+        showConsentBanner: shouldShowBanner,
+        jurisdiction,
+        location,
+        translations: getTranslations(acceptLanguage, customTranslations),
+        branding: branding
+    };
+}
+const handler_showConsentBanner = os.consent.showBanner.handler(({ context })=>{
+    const typedContext = context;
+    const { customTranslations, disableGeoLocation, branding } = typedContext.advanced ?? {};
+    const { countryCode, regionCode, acceptLanguage } = getHeaders(typedContext.headers);
+    if (disableGeoLocation) return buildResponse({
+        shouldShowBanner: true,
+        jurisdiction: {
+            code: 'NONE',
+            message: JurisdictionMessages.NONE
+        },
+        location: {
+            countryCode: null,
+            regionCode: null
+        },
+        acceptLanguage,
+        customTranslations,
+        branding
+    });
+    const { showConsentBanner, jurisdictionCode, message } = checkJurisdiction(countryCode);
+    return buildResponse({
+        shouldShowBanner: showConsentBanner,
+        jurisdiction: {
+            code: jurisdictionCode,
+            message
+        },
+        location: {
+            countryCode,
+            regionCode
+        },
+        acceptLanguage,
+        customTranslations,
+        branding
+    });
+});
+const verifyConsent = os.consent.verify.handler(async ({ input, context })=>{
+    const typedContext = context;
+    const logger = typedContext.logger;
+    logger.info('Handling verify-consent request');
+    const { type, subjectId, externalSubjectId, domain, policyId, preferences } = input;
+    logger.debug('Request parameters', {
+        type,
+        subjectId,
+        externalSubjectId,
+        domain,
+        policyId,
+        preferences
+    });
+    try {
+        const domainRecord = await typedContext.registry.findDomainByName(domain);
+        if (!domainRecord) throw new __WEBPACK_EXTERNAL_MODULE__orpc_server_0dae8408__.ORPCError('DOMAIN_NOT_FOUND', {
+            data: {
+                domain
+            }
+        });
+        const subject = await typedContext.registry.findOrCreateSubject({
+            subjectId,
+            externalSubjectId,
+            ipAddress: typedContext.ipAddress ?? 'unknown'
+        });
+        if (!subject) throw new __WEBPACK_EXTERNAL_MODULE__orpc_server_0dae8408__.ORPCError('SUBJECT_NOT_FOUND', {
+            data: {
+                subjectId,
+                externalSubjectId
+            }
+        });
+        if ('cookie_banner' === type && (!preferences || 0 === preferences.length)) throw new __WEBPACK_EXTERNAL_MODULE__orpc_server_0dae8408__.ORPCError('COOKIE_BANNER_PREFERENCES_REQUIRED', {
+            data: {
+                type: 'cookie_banner'
+            }
+        });
+        const purposePromises = preferences?.map((purpose)=>typedContext.registry.findOrCreateConsentPurposeByCode(purpose));
+        const rawPurposes = await Promise.all(purposePromises ?? []);
+        const purposeIds = rawPurposes.filter((purpose)=>null !== purpose).map((purpose)=>purpose.id);
+        if (purposeIds.length !== (preferences?.length ?? 0)) throw new __WEBPACK_EXTERNAL_MODULE__orpc_server_0dae8408__.ORPCError('PURPOSES_NOT_FOUND', {
+            data: {
+                preferences: preferences ?? [],
+                foundPurposes: rawPurposes.filter((p)=>null !== p).map((p)=>p.code)
+            }
+        });
+        if (policyId) {
+            const policy = await typedContext.registry.findConsentPolicyById(policyId);
+            if (!policy || policy.type !== type) throw new __WEBPACK_EXTERNAL_MODULE__orpc_server_0dae8408__.ORPCError('POLICY_NOT_FOUND', {
+                data: {
+                    policyId,
+                    type
+                }
+            });
+            return await checkPolicyConsent({
+                policyId: policy.id,
+                subjectId: subject.id,
+                domainId: domainRecord.id,
+                purposeIds,
+                type,
+                context: typedContext
+            });
+        }
+        const latestPolicy = await typedContext.registry.findOrCreatePolicy(type);
+        if (!latestPolicy) throw new __WEBPACK_EXTERNAL_MODULE__orpc_server_0dae8408__.ORPCError('POLICY_NOT_FOUND', {
+            data: {
+                policyId: 'latest',
+                type
+            }
+        });
+        return await checkPolicyConsent({
+            policyId: latestPolicy.id,
+            subjectId: subject.id,
+            domainId: domainRecord.id,
+            purposeIds,
+            type,
+            context: typedContext
+        });
+    } catch (error) {
+        logger.error('Error in verify-consent handler', {
+            error: error instanceof Error ? error.message : String(error),
+            errorType: error instanceof Error ? error.constructor.name : typeof error
+        });
+        if (error instanceof __WEBPACK_EXTERNAL_MODULE__orpc_server_0dae8408__.ORPCError) throw error;
+        throw new __WEBPACK_EXTERNAL_MODULE__orpc_server_0dae8408__.ORPCError('INTERNAL_SERVER_ERROR', {
+            message: error instanceof Error ? error.message : String(error)
+        });
+    }
+});
+async function checkPolicyConsent({ policyId, subjectId, domainId, purposeIds, type, context }) {
+    const { registry, db } = context;
+    const rawConsents = await db.findMany('consent', {
+        where: (b)=>b.and(b('subjectId', '=', subjectId), b('policyId', '=', policyId), b('domainId', '=', domainId)),
+        orderBy: [
+            'givenAt',
+            'desc'
+        ]
+    });
+    const filteredConsents = rawConsents.filter((consent)=>{
+        if (!purposeIds) return true;
+        return purposeIds.every((id)=>consent.purposeIds.some((purposeId)=>purposeId === id));
+    });
+    await registry.createAuditLog({
+        subjectId,
+        entityType: 'consent_policy',
+        entityId: policyId,
+        actionType: 'verify_consent',
+        metadata: {
+            type,
+            policyId,
+            purposeIds,
+            success: 0 !== filteredConsents.length,
+            ...filteredConsents.length > 0 ? {
+                consentId: filteredConsents[0]?.id
+            } : {}
+        },
+        eventTimezone: 'UTC'
+    });
+    if (0 === rawConsents.length || 0 === filteredConsents.length) return {
+        isValid: false
+    };
+    return {
+        isValid: true,
+        consent: filteredConsents[0]
+    };
+}
+const consentHandlers = {
+    post: postConsent,
+    showBanner: handler_showConsentBanner,
+    verify: verifyConsent
+};
+const statusHandler = os.meta.status.handler(({ context })=>{
+    const typedContext = context;
+    const headers = typedContext.headers;
+    const normalizeHeader = (value)=>{
+        if (!value) return null;
+        return Array.isArray(value) ? value[0] ?? null : value;
+    };
+    const countryCode = normalizeHeader(headers?.get('cf-ipcountry')) ?? normalizeHeader(headers?.get('x-vercel-ip-country')) ?? normalizeHeader(headers?.get('x-amz-cf-ipcountry')) ?? normalizeHeader(headers?.get('x-country-code'));
+    const regionCode = normalizeHeader(headers?.get('x-vercel-ip-country-region')) ?? normalizeHeader(headers?.get('x-region-code'));
+    return {
+        status: 'ok',
+        version: version,
+        timestamp: new Date(),
+        client: {
+            ip: typedContext.ipAddress ?? null,
+            userAgent: typedContext.userAgent ?? null,
+            region: {
+                countryCode,
+                regionCode
+            }
+        }
+    };
+});
+const metaHandlers = {
+    status: statusHandler
+};
+const router = os.router({
+    consent: consentHandlers,
+    meta: metaHandlers
+});
+const mergeOpenAPIOptions = (defaultOptions, userOptions)=>{
+    const merged = {
+        ...defaultOptions
+    };
+    if (userOptions.info && 'object' == typeof userOptions.info) merged.info = {
+        ...merged.info,
+        ...userOptions.info
+    };
+    for (const [key, value] of Object.entries(userOptions))if ('info' !== key) merged[key] = value;
+    return merged;
+};
+const createOpenAPISpec = (context, options)=>{
+    const openAPIGenerator = new __WEBPACK_EXTERNAL_MODULE__orpc_openapi_a95cc8e7__.OpenAPIGenerator({
+        schemaConverters: [
+            new __WEBPACK_EXTERNAL_MODULE__orpc_zod_716a28d4__.ZodToJsonSchemaConverter()
+        ]
+    });
+    const getOpenAPISpec = async ()=>{
+        if (getOpenAPISpec.cached) return getOpenAPISpec.cached;
+        const defaultOptions = createDefaultOpenAPIOptions(options);
+        const mergedOptions = options.advanced?.openapi?.options ? mergeOpenAPIOptions(defaultOptions, options.advanced.openapi.options) : defaultOptions;
+        try {
+            const spec = await openAPIGenerator.generate(router, mergedOptions);
+            getOpenAPISpec.cached = spec;
+            return spec;
+        } catch (error) {
+            context.logger?.error('Failed to generate OpenAPI spec:', error);
+            return {
+                openapi: '3.0.0',
+                info: {
+                    title: options.appName || 'c15t API',
+                    version: '0.0.0'
+                },
+                paths: {}
+            };
+        }
+    };
+    return getOpenAPISpec;
+};
+const createDocsUI = (options)=>{
+    const config = createOpenAPIConfig(options);
+    if (config.customUiTemplate) return config.customUiTemplate;
+    return `
+    <!doctype html>
+    <html>
+      <head>
+        <title>${options.appName || 'c15t API'} Documentation</title>
+        <meta charset="utf-8" />
+        <meta name="viewport" content="width=device-width, initial-scale=1" />
+        <link rel="icon" type="image/svg+xml" href="https://c15t.com/icon.svg" />
+      </head>
+      <body>
+        <script
+          id="api-reference"
+          data-url="${encodeURI(config.specPath)}">
+        </script>
+        <script src="https://cdn.jsdelivr.net/npm/@scalar/api-reference"></script>
+      </body>
+    </html>
+  `;
+};
+const DEFAULT_IP_HEADERS = [
+    'x-client-ip',
+    'x-forwarded-for',
+    'cf-connecting-ip',
+    'fastly-client-ip',
+    'x-real-ip',
+    'x-cluster-client-ip',
+    'x-forwarded',
+    'forwarded-for',
+    'forwarded'
+];
+function getIpAddress(req, options) {
+    const ipAddress = options.advanced?.ipAddress;
+    if (ipAddress?.disableIpTracking) return 'unknown';
+    const ipHeaders = ipAddress?.ipAddressHeaders || DEFAULT_IP_HEADERS;
+    const headers = req instanceof Request ? req.headers : req;
+    for (const key of ipHeaders){
+        const value = headers.get(key);
+        if (value) {
+            const ip = value.split(',')[0]?.trim();
+            if (ip) return ip;
+        }
+    }
+    return 'unknown';
+}
+const generate_id_prefixes = {
+    auditLog: 'log',
+    consent: 'cns',
+    consentPolicy: 'pol',
+    consentPurpose: 'pur',
+    consentRecord: 'rec',
+    domain: 'dom',
+    subject: 'sub'
+};
+const generate_id_b58 = (0, __WEBPACK_EXTERNAL_MODULE_base_x_aeb88370__["default"])('123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz');
+function generate_id_generateId(model) {
+    const buf = crypto.getRandomValues(new Uint8Array(20));
+    const prefix = generate_id_prefixes[model];
+    const EPOCH_TIMESTAMP = 1700000000000;
+    const t = Date.now() - EPOCH_TIMESTAMP;
+    const high = Math.floor(t / 0x100000000);
+    const low = t >>> 0;
+    buf[0] = high >>> 24 & 255;
+    buf[1] = high >>> 16 & 255;
+    buf[2] = high >>> 8 & 255;
+    buf[3] = 255 & high;
+    buf[4] = low >>> 24 & 255;
+    buf[5] = low >>> 16 & 255;
+    buf[6] = low >>> 8 & 255;
+    buf[7] = 255 & low;
+    return `${prefix}_${generate_id_b58.encode(buf)}`;
+}
+async function generate_id_generateUniqueId(db, model, ctx, options = {}) {
+    const { maxRetries = 10, attempt = 0, baseDelay = 5 } = options;
+    if (attempt >= maxRetries) {
+        const error = new Error(`Failed to generate unique ID for ${model} after ${maxRetries} attempts`);
+        ctx?.logger?.error?.('ID generation failed', {
+            model,
+            maxRetries
+        });
+        throw error;
+    }
+    const id = generate_id_generateId(model);
+    try {
+        const existing = await db.findFirst(model, {
+            where: (b)=>b('id', '=', id)
+        });
+        if (existing) {
+            ctx?.logger?.debug?.('ID conflict detected', {
+                id,
+                model,
+                attempt: attempt + 1,
+                maxRetries
+            });
+            const delay = Math.min(baseDelay * 2 ** attempt, 1000);
+            await new Promise((resolve)=>setTimeout(resolve, delay));
+            return generate_id_generateUniqueId(db, model, ctx, {
+                maxRetries,
+                attempt: attempt + 1,
+                baseDelay
+            });
+        }
+        return id;
+    } catch (error) {
+        ctx?.logger?.error?.('Error checking ID uniqueness', {
+            error: error.message,
+            model,
+            attempt
+        });
+        if (attempt < maxRetries - 1) {
+            const delay = Math.min(baseDelay * 2 ** attempt, 2000);
+            await new Promise((resolve)=>setTimeout(resolve, delay));
+            return generate_id_generateUniqueId(db, model, ctx, {
+                maxRetries,
+                attempt: attempt + 1,
+                baseDelay
+            });
+        }
+        throw error;
+    }
+}
+function auditLogRegistry({ db, ctx }) {
+    const logger = ctx?.logger ?? {
+        debug: ()=>void 0,
+        error: ()=>void 0
+    };
+    return {
+        createAuditLog: async (auditLog)=>{
+            logger.debug('Creating audit log', {
+                auditLog
+            });
+            const createdLog = await db.create('auditLog', {
+                id: await generate_id_generateUniqueId(db, 'auditLog', ctx),
+                createdAt: new Date(),
+                ...auditLog
+            });
+            if (!createdLog) {
+                logger.error('Failed to create audit log', {
+                    auditLog
+                });
+                throw new __WEBPACK_EXTERNAL_MODULE__orpc_server_0dae8408__.ORPCError('INTERNAL_SERVER_ERROR', {
+                    message: 'Failed to create audit log',
+                    status: 500
+                });
+            }
+            return createdLog;
+        }
+    };
+}
+function consentRegistry({ db, ctx }) {
+    const { logger } = ctx;
+    return {
+        createConsent: async (consent)=>{
+            logger.debug('Creating consent', {
+                consent
+            });
+            const createdConsent = await db.create('consent', {
+                id: await generate_id_generateUniqueId(db, 'consent', ctx),
+                subjectId: consent.subjectId,
+                domainId: consent.domainId,
+                policyId: consent.policyId,
+                purposeIds: consent.purposeIds,
+                metadata: consent.metadata,
+                ipAddress: consent.ipAddress,
+                userAgent: consent.userAgent,
+                status: consent.status,
+                givenAt: consent.givenAt,
+                isActive: consent.isActive
+            });
+            if (!createdConsent) throw new __WEBPACK_EXTERNAL_MODULE__orpc_server_0dae8408__.ORPCError('CONSENT_CREATION_FAILED', {
+                message: 'Failed to create consent - operation returned null',
+                status: 500,
+                data: {
+                    subjectId: consent.subjectId,
+                    domainId: consent.domainId
+                }
+            });
+            return createdConsent;
+        }
+    };
+}
+function policyRegistry({ db, ctx }) {
+    const { logger } = ctx;
+    async function generatePolicyPlaceholder(name, date) {
+        const content = `[PLACEHOLDER] This is an automatically generated version of the ${name} policy.\n\nThis placeholder content should be replaced with actual policy terms before being presented to users.\n\nGenerated on: ${date.toISOString()}`;
+        let contentHash;
+        try {
+            const encoder = new TextEncoder();
+            const data = encoder.encode(content);
+            const hashBuffer = await crypto.subtle.digest('SHA-256', data);
+            contentHash = Array.from(new Uint8Array(hashBuffer)).map((b)=>b.toString(16).padStart(2, '0')).join('');
+        } catch  {
+            throw new __WEBPACK_EXTERNAL_MODULE__orpc_server_0dae8408__.ORPCError('POLICY_CREATION_FAILED', {
+                message: 'Failed to generate policy content hash',
+                status: 500,
+                data: {
+                    name
+                }
+            });
+        }
+        return {
+            content,
+            contentHash
+        };
+    }
+    return {
+        findConsentPolicyById: async (policyId)=>{
+            const policy = await db.findFirst('consentPolicy', {
+                where: (b)=>b('id', '=', policyId)
+            });
+            return policy;
+        },
+        findOrCreatePolicy: async (type)=>{
+            const existingPolicy = await db.findFirst('consentPolicy', {
+                where: (b)=>b.and(b('isActive', '=', true), b('type', '=', type)),
+                orderBy: [
+                    'effectiveDate',
+                    'desc'
+                ]
+            });
+            if (existingPolicy) {
+                logger.debug('Found existing policy', {
+                    type,
+                    policyId: existingPolicy.id
+                });
+                return existingPolicy;
+            }
+            const { content, contentHash } = await generatePolicyPlaceholder(type, new Date());
+            const policy = await db.create('consentPolicy', {
+                id: await generate_id_generateUniqueId(db, 'consentPolicy', ctx),
+                version: '1.0.0',
+                type,
+                name: type,
+                effectiveDate: new Date(),
+                content,
+                contentHash,
+                isActive: true,
+                expirationDate: null
+            });
+            return policy;
+        }
+    };
+}
+function consentPurposeRegistry({ db, ctx }) {
+    const { logger } = ctx;
+    return {
+        findOrCreateConsentPurposeByCode: async (code)=>{
+            const existingPurpose = await db.findFirst('consentPurpose', {
+                where: (b)=>b('code', '=', code)
+            });
+            if (existingPurpose) {
+                logger.debug('Found existing consent purpose', {
+                    code
+                });
+                return existingPurpose;
+            }
+            logger.debug('Creating consent purpose', {
+                code
+            });
+            const createdPurpose = await db.create('consentPurpose', {
+                id: await generate_id_generateUniqueId(db, 'consentPurpose', ctx),
+                code,
+                name: code,
+                description: `Auto-created consentPurpose for ${code}`,
+                isActive: true,
+                isEssential: false,
+                legalBasis: 'consent'
+            });
+            if (!createdPurpose) throw new __WEBPACK_EXTERNAL_MODULE__orpc_server_0dae8408__.ORPCError('PURPOSE_CREATION_FAILED', {
+                message: 'Failed to create consent purpose',
+                status: 500,
+                data: {
+                    purposeCode: code
+                }
+            });
+            return createdPurpose;
+        }
+    };
+}
+function domainRegistry({ db, ctx }) {
+    const { logger } = ctx;
+    const findDomainByName = async (name)=>{
+        const domain = await db.findFirst('domain', {
+            where: (b)=>b('name', '=', name)
+        });
+        if (!domain) logger.debug('No domain found', {
+            name
+        });
+        return domain;
+    };
+    return {
+        findDomainByName,
+        findOrCreateDomain: async (name)=>{
+            const existingDomain = await findDomainByName(name);
+            if (existingDomain) {
+                logger.debug('Found existing domain', {
+                    name
+                });
+                return existingDomain;
+            }
+            logger.debug('Creating new domain', {
+                name
+            });
+            const domain = await db.create('domain', {
+                id: await generate_id_generateUniqueId(db, 'domain', ctx),
+                name,
+                description: `Auto-created domain for ${name}`,
+                isActive: true,
+                isVerified: true,
+                allowedOrigins: []
+            });
+            if (!domain) throw new __WEBPACK_EXTERNAL_MODULE__orpc_server_0dae8408__.ORPCError('DOMAIN_CREATION_FAILED', {
+                message: 'Failed to create domain',
+                status: 503,
+                data: {
+                    name
+                }
+            });
+            return domain;
+        }
+    };
+}
+function subjectRegistry({ db, ctx }) {
+    const { logger } = ctx;
+    return {
+        findOrCreateSubject: async ({ subjectId, externalSubjectId, ipAddress = 'unknown' })=>{
+            if (subjectId && externalSubjectId) {
+                const subject = await db.findFirst('subject', {
+                    where: (b)=>b.and(b('id', '=', subjectId), b('externalId', '=', externalSubjectId))
+                });
+                if (!subject) {
+                    logger?.error('Subject not found', {
+                        providedSubjectId: subjectId,
+                        providedExternalId: externalSubjectId
+                    });
+                    throw new __WEBPACK_EXTERNAL_MODULE__orpc_server_0dae8408__.ORPCError('SUBJECT_NOT_FOUND', {
+                        message: 'The specified subject could not be found. Please verify the subject identifiers and try again.',
+                        status: 404,
+                        data: {
+                            providedSubjectId: subjectId,
+                            providedExternalId: externalSubjectId
+                        }
+                    });
+                }
+                return subject;
+            }
+            if (subjectId) {
+                const subject = await db.findFirst('subject', {
+                    where: (b)=>b('id', '=', subjectId)
+                });
+                if (!subject) throw new __WEBPACK_EXTERNAL_MODULE__orpc_server_0dae8408__.ORPCError('SUBJECT_NOT_FOUND', {
+                    message: 'Subject not found by subjectId',
+                    status: 404,
+                    data: {
+                        subjectId
+                    }
+                });
+                return subject;
+            }
+            if (externalSubjectId) {
+                logger.debug('Finding/Creating subject with external id');
+                await db.upsert('subject', {
+                    where: (b)=>b('externalId', '=', externalSubjectId),
+                    create: {
+                        id: await generate_id_generateUniqueId(db, 'subject', ctx),
+                        externalId: externalSubjectId,
+                        identityProvider: 'anonymous',
+                        lastIpAddress: ipAddress,
+                        isIdentified: !!externalSubjectId
+                    },
+                    update: {
+                        lastIpAddress: ipAddress
+                    }
+                });
+                const subject = await db.findFirst('subject', {
+                    where: (b)=>b('externalId', '=', externalSubjectId)
+                });
+                return subject;
+            }
+            logger?.debug('Creating new anonymous subject');
+            const subject = await db.create('subject', {
+                id: await generate_id_generateUniqueId(db, 'subject', ctx),
+                externalId: null,
+                identityProvider: 'anonymous',
+                lastIpAddress: ipAddress,
+                isIdentified: false
+            });
+            logger.debug('Created new anonymous subject', {
+                subject
+            });
+            return subject;
+        }
+    };
+}
+const createRegistry = (ctx)=>({
+        ...auditLogRegistry(ctx),
+        ...subjectRegistry(ctx),
+        ...consentRegistry(ctx),
+        ...consentPurposeRegistry(ctx),
+        ...policyRegistry(ctx),
+        ...domainRegistry(ctx)
+    });
+function createTelemetryOptions(appName = 'c15t', telemetryConfig) {
+    const config = {
+        disabled: telemetryConfig?.disabled ?? false,
+        tracer: telemetryConfig?.tracer,
+        defaultAttributes: {
+            ...telemetryConfig?.defaultAttributes || {},
+            'service.name': String(appName),
+            'service.version': version
+        }
+    };
+    return config;
+}
+const getTracer = (options)=>{
+    if (options?.advanced?.telemetry?.tracer) return options.advanced.telemetry.tracer;
+    return __WEBPACK_EXTERNAL_MODULE__opentelemetry_api_87359e78__.trace.getTracer(options?.appName ?? 'c15t');
+};
+const createRequestSpan = (method, path, options)=>{
+    if (options?.advanced?.telemetry?.disabled) return null;
+    const tracer = getTracer(options);
+    const span = tracer.startSpan(`${method} ${path}`, {
+        attributes: {
+            'http.method': method,
+            'http.path': path,
+            ...options?.advanced?.telemetry?.defaultAttributes || {}
+        }
+    });
+    return span;
+};
+const withRequestSpan = async (method, path, operation, options)=>{
+    const span = createRequestSpan(method, path, options);
+    if (!span) return operation();
+    try {
+        const result = await operation();
+        span.setStatus({
+            code: __WEBPACK_EXTERNAL_MODULE__opentelemetry_api_87359e78__.SpanStatusCode.OK
+        });
+        return result;
+    } catch (error) {
+        handleSpanError(span, error);
+        throw error;
+    } finally{
+        span.end();
+    }
+};
+const handleSpanError = (span, error)=>{
+    span.setStatus({
+        code: __WEBPACK_EXTERNAL_MODULE__opentelemetry_api_87359e78__.SpanStatusCode.ERROR,
+        message: error instanceof Error ? error.message : String(error)
+    });
+    if (error instanceof Error) {
+        span.setAttribute('error.type', error.name);
+        span.setAttribute('error.message', error.message);
+        if (error.stack) span.setAttribute('error.stack', error.stack);
+    }
+};
+let globalLogger;
+function initLogger(options) {
+    globalLogger = (0, __WEBPACK_EXTERNAL_MODULE__doubletie_logger_91c58a8f__.createLogger)(options);
+    return globalLogger;
+}
+let telemetrySdk;
+const initializeTelemetry = (appName, telemetryOptions, logger)=>{
+    if (telemetrySdk) {
+        logger.debug('Telemetry SDK already initialized, skipping');
+        return true;
+    }
+    if (telemetryOptions?.disabled) {
+        logger.info('Telemetry is disabled by configuration');
+        return false;
+    }
+    try {
+        const resource = (0, __WEBPACK_EXTERNAL_MODULE__opentelemetry_resources_c7ac8648__.resourceFromAttributes)({
+            'service.name': appName,
+            'service.version': version,
+            ...telemetryOptions?.defaultAttributes || {}
+        });
+        logger.debug('Initializing telemetry with resource attributes', {
+            attributes: resource.attributes
+        });
+        const traceExporter = telemetryOptions?.tracer ? void 0 : new __WEBPACK_EXTERNAL_MODULE__opentelemetry_sdk_trace_base_5031a705__.ConsoleSpanExporter();
+        telemetrySdk = new __WEBPACK_EXTERNAL_MODULE__opentelemetry_sdk_node_50b75088__.NodeSDK({
+            resource,
+            traceExporter
+        });
+        telemetrySdk.start();
+        logger.info('Telemetry successfully initialized');
+        return true;
+    } catch (error) {
+        logger.error('Telemetry initialization failed', {
+            error: error instanceof Error ? error.message : String(error),
+            stack: error instanceof Error ? error.stack : void 0
+        });
+        logger.warn('Continuing without telemetry');
+        return false;
+    }
+};
+const init = (options)=>{
+    const appName = options.appName || 'c15t';
+    const logger = initLogger({
+        ...options.logger,
+        appName: String(appName)
+    });
+    const telemetryOptions = createTelemetryOptions(String(appName), options.advanced?.telemetry);
+    const telemetryInitialized = initializeTelemetry(String(appName), telemetryOptions, logger);
+    if (telemetryOptions?.disabled) logger.info('Telemetry is disabled by configuration');
+    else if (telemetryInitialized) logger.info('Telemetry initialized successfully');
+    else logger.warn('Telemetry initialization failed, continuing without telemetry');
+    const client = DB.client(options.adapter);
+    const orm = client.orm('1.0.0');
+    const context = {
+        ...options,
+        appName,
+        logger,
+        db: orm,
+        registry: createRegistry({
+            db: orm,
+            ctx: {
+                logger
+            }
+        })
+    };
+    return context;
+};
+const defineConfig = (config)=>config;
+const c15tInstance = (options)=>{
+    const context = init(options);
+    const corsOptions = createCORSOptions(options.trustedOrigins);
+    const rpcHandler = new __WEBPACK_EXTERNAL_MODULE__orpc_openapi_fetch_89b49e61__.OpenAPIHandler(router, {
+        plugins: [
+            new __WEBPACK_EXTERNAL_MODULE__orpc_server_plugins_e445fd4f__.CORSPlugin(corsOptions)
+        ]
+    });
+    const openApiConfig = createOpenAPIConfig(options);
+    const getDocsUI = ()=>createDocsUI(options);
+    const processTelemetry = (request, context)=>{
+        const url = new URL(request.url);
+        const path = url.pathname;
+        const method = request.method;
+        withRequestSpan(method, path, async ()=>{}, options);
+        context.path = path;
+        context.method = method;
+        context.headers = request.headers;
+        context.userAgent = request.headers.get('user-agent') || void 0;
+        return context;
+    };
+    const handleOpenApiSpecRequest = async (url)=>{
+        if (openApiConfig.enabled && url.pathname === openApiConfig.specPath) {
+            const getOpenAPISpec = createOpenAPISpec(context, options);
+            const spec = await getOpenAPISpec();
+            return new Response(JSON.stringify(spec), {
+                status: 200,
+                headers: {
+                    'Content-Type': 'application/json'
+                }
+            });
+        }
+        return null;
+    };
+    const handleDocsUiRequest = (url)=>{
+        if (openApiConfig.enabled && url.pathname === openApiConfig.docsPath) {
+            const html = getDocsUI();
+            return new Response(html, {
+                status: 200,
+                headers: {
+                    'Content-Type': 'text/html',
+                    'Content-Security-Policy': "default-src 'self'; script-src 'self' https://cdn.jsdelivr.net; style-src 'self' 'unsafe-inline' https://cdn.jsdelivr.net;"
+                }
+            });
+        }
+        return null;
+    };
+    const createORPCErrorResponse = (error)=>{
+        const sanitizedMessage = error.message.replace(/[^\w\s.,;:!?()[\]{}'"+-]/g, '');
+        return new Response(JSON.stringify({
+            code: error.code,
+            message: sanitizedMessage,
+            data: error.data ?? {},
+            status: error.status,
+            defined: true
+        }), {
+            status: error.status,
+            headers: {
+                'Content-Type': 'application/json'
+            }
+        });
+    };
+    const createUnknownErrorResponse = (error)=>{
+        const message = error instanceof Error ? error.message : String(error);
+        let status = 500;
+        if (error instanceof Error && 'status' in error) {
+            const statusValue = error.status;
+            if ('number' == typeof statusValue && statusValue >= 100 && statusValue < 600) status = statusValue;
+        }
+        return new Response(JSON.stringify({
+            code: 'INTERNAL_SERVER_ERROR',
+            message,
+            status,
+            defined: true,
+            data: {}
+        }), {
+            status,
+            headers: {
+                'Content-Type': 'application/json'
+            }
+        });
+    };
+    const handleApiRequest = async (request, ctx)=>{
+        const { logger } = ctx;
+        const enrichedContext = {
+            ...context,
+            ipAddress: getIpAddress(request, options),
+            userAgent: request.headers.get('user-agent') || void 0
+        };
+        processCors(request, enrichedContext, options.trustedOrigins);
+        processTelemetry(request, enrichedContext);
+        logger.debug?.('Handling prefix', {
+            prefix: options.basePath || '/'
+        });
+        const { matched, response } = await rpcHandler.handle(request, {
+            prefix: options.basePath || '/',
+            context: enrichedContext
+        });
+        if (matched && response) {
+            logger.debug('Handler matched', {
+                request,
+                matched,
+                response
+            });
+            return response;
+        }
+        logger.debug('No handler matched', {
+            request,
+            matched,
+            response
+        });
+        return new Response('Not Found', {
+            status: 404
+        });
+    };
+    const handler = async (request, ctxOverride)=>{
+        try {
+            const url = new URL(request.url);
+            (0, __WEBPACK_EXTERNAL_MODULE__doubletie_logger_91c58a8f__.createLogger)(options.logger)?.debug?.('Incoming request', {
+                method: request.method,
+                pathname: url.pathname
+            });
+            const openApiResponse = await handleOpenApiSpecRequest(url);
+            if (openApiResponse) return openApiResponse;
+            const docsResponse = handleDocsUiRequest(url);
+            if (docsResponse) return docsResponse;
+            const ctx = (0, __WEBPACK_EXTERNAL_MODULE_defu__["default"])(ctxOverride || {}, context);
+            const basePath = options.basePath;
+            (0, __WEBPACK_EXTERNAL_MODULE__doubletie_logger_91c58a8f__.createLogger)(options.logger)?.debug?.('[c15t] Using basePath', {
+                basePath
+            });
+            (0, __WEBPACK_EXTERNAL_MODULE__doubletie_logger_91c58a8f__.createLogger)(options.logger)?.debug?.('[c15t] Routing request', {
+                method: request.method,
+                url: request.url,
+                prefix: basePath
+            });
+            return await handleApiRequest(request, ctx);
+        } catch (error) {
+            const logger = options.logger ? (0, __WEBPACK_EXTERNAL_MODULE__doubletie_logger_91c58a8f__.createLogger)(options.logger) : console;
+            logger.error('Request handling error:', error);
+            if (error instanceof __WEBPACK_EXTERNAL_MODULE__orpc_server_0dae8408__.ORPCError) return createORPCErrorResponse(error);
+            return createUnknownErrorResponse(error);
+        }
+    };
+    const createNextHandlers = ()=>{
+        const nextHandler = async (request)=>await handler(request);
+        return {
+            GET: nextHandler,
+            POST: nextHandler,
+            PUT: nextHandler,
+            PATCH: nextHandler,
+            DELETE: nextHandler,
+            OPTIONS: nextHandler,
+            HEAD: nextHandler
+        };
+    };
+    return {
+        options,
+        $context: context,
+        router: router,
+        handler,
+        ...createNextHandlers(),
+        getOpenAPISpec: ()=>{
+            const getOpenAPISpec = createOpenAPISpec(context, options);
+            return getOpenAPISpec();
+        },
+        getDocsUI
+    };
+};
+export { c15tInstance, defineConfig, version };