@c15t/backend 1.8.0 → 2.0.0-rc.1

package/dist/v2/router.cjs

@@ -1,1442 +0,0 @@
-"use strict";
-var __webpack_require__ = {};
-(()=>{
-    __webpack_require__.n = (module)=>{
-        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
-        __webpack_require__.d(getter, {
-            a: getter
-        });
-        return getter;
-    };
-})();
-(()=>{
-    __webpack_require__.d = (exports1, definition)=>{
-        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
-            enumerable: true,
-            get: definition[key]
-        });
-    };
-})();
-(()=>{
-    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
-})();
-(()=>{
-    __webpack_require__.r = (exports1)=>{
-        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
-            value: 'Module'
-        });
-        Object.defineProperty(exports1, '__esModule', {
-            value: true
-        });
-    };
-})();
-var __webpack_exports__ = {};
-__webpack_require__.r(__webpack_exports__);
-__webpack_require__.d(__webpack_exports__, {
-    router: ()=>router
-});
-const server_namespaceObject = require("@orpc/server");
-const contract_namespaceObject = require("@orpc/contract");
-const external_zod_namespaceObject = require("zod");
-const identifyUserSchema = external_zod_namespaceObject.z.object({
-    consentId: external_zod_namespaceObject.z.string(),
-    externalId: external_zod_namespaceObject.z.string(),
-    identityProvider: external_zod_namespaceObject.z.string().optional()
-});
-const identifyUserContract = contract_namespaceObject.oc.route({
-    method: 'PATCH',
-    path: '/consent/identify',
-    description: "Links a subject's external ID to a consent record by consent ID. This is used to identify a user across multiple devices and sessions.",
-    tags: [
-        'consent',
-        'cookie-banner'
-    ]
-}).errors({
-    CONSENT_NOT_FOUND: {
-        status: 404,
-        data: external_zod_namespaceObject.z.object({
-            consentId: external_zod_namespaceObject.z.string()
-        }),
-        error: 'Consent not found'
-    },
-    IDENTIFICATION_FAILED: {
-        status: 500,
-        data: external_zod_namespaceObject.z.object({
-            consentId: external_zod_namespaceObject.z.string()
-        }),
-        error: 'Failed to identify user'
-    }
-}).input(identifyUserSchema).output(external_zod_namespaceObject.z.object({
-    success: external_zod_namespaceObject.z.boolean()
-}));
-const external_fumadb_namespaceObject = require("fumadb");
-const schema_namespaceObject = require("fumadb/schema");
-const auditLogTable = (0, schema_namespaceObject.table)('auditLog', {
-    id: (0, schema_namespaceObject.idColumn)('id', 'varchar(255)'),
-    entityType: (0, schema_namespaceObject.column)('entityType', 'string'),
-    entityId: (0, schema_namespaceObject.column)('entityId', 'string'),
-    actionType: (0, schema_namespaceObject.column)('actionType', 'string'),
-    subjectId: (0, schema_namespaceObject.column)('subjectId', 'string').nullable(),
-    ipAddress: (0, schema_namespaceObject.column)('ipAddress', 'string').nullable(),
-    userAgent: (0, schema_namespaceObject.column)('userAgent', 'string').nullable(),
-    changes: (0, schema_namespaceObject.column)('changes', 'json').nullable(),
-    metadata: (0, schema_namespaceObject.column)('metadata', 'json').nullable(),
-    createdAt: (0, schema_namespaceObject.column)('createdAt', 'timestamp').defaultTo$('now'),
-    eventTimezone: (0, schema_namespaceObject.column)('eventTimezone', 'string').defaultTo$(()=>'UTC')
-});
-external_zod_namespaceObject.z.object({
-    id: external_zod_namespaceObject.z.string(),
-    entityType: external_zod_namespaceObject.z.string(),
-    entityId: external_zod_namespaceObject.z.string(),
-    actionType: external_zod_namespaceObject.z.string(),
-    subjectId: external_zod_namespaceObject.z.string().optional(),
-    ipAddress: external_zod_namespaceObject.z.string().optional(),
-    userAgent: external_zod_namespaceObject.z.string().optional(),
-    changes: external_zod_namespaceObject.z.record(external_zod_namespaceObject.z.string(), external_zod_namespaceObject.z.unknown()).optional(),
-    metadata: external_zod_namespaceObject.z.record(external_zod_namespaceObject.z.string(), external_zod_namespaceObject.z.unknown()).optional(),
-    createdAt: external_zod_namespaceObject.z.date().prefault(()=>new Date()),
-    eventTimezone: external_zod_namespaceObject.z.string().prefault('UTC')
-});
-const consentTable = (0, schema_namespaceObject.table)('consent', {
-    id: (0, schema_namespaceObject.idColumn)('id', 'varchar(255)'),
-    subjectId: (0, schema_namespaceObject.column)('subjectId', 'string'),
-    domainId: (0, schema_namespaceObject.column)('domainId', 'string'),
-    policyId: (0, schema_namespaceObject.column)('policyId', 'string').nullable(),
-    purposeIds: (0, schema_namespaceObject.column)('purposeIds', 'json'),
-    metadata: (0, schema_namespaceObject.column)('metadata', 'json').nullable(),
-    ipAddress: (0, schema_namespaceObject.column)('ipAddress', 'string').nullable(),
-    userAgent: (0, schema_namespaceObject.column)('userAgent', 'string').nullable(),
-    status: (0, schema_namespaceObject.column)('status', 'string').defaultTo$(()=>'active'),
-    withdrawalReason: (0, schema_namespaceObject.column)('withdrawalReason', 'string').nullable(),
-    givenAt: (0, schema_namespaceObject.column)('givenAt', 'timestamp').defaultTo$('now'),
-    validUntil: (0, schema_namespaceObject.column)('validUntil', 'timestamp').nullable(),
-    isActive: (0, schema_namespaceObject.column)('isActive', 'bool').defaultTo$(()=>true)
-});
-const consentStatusSchema = external_zod_namespaceObject.z["enum"]([
-    'active',
-    'withdrawn',
-    'expired'
-]);
-external_zod_namespaceObject.z.object({
-    id: external_zod_namespaceObject.z.string(),
-    subjectId: external_zod_namespaceObject.z.string(),
-    domainId: external_zod_namespaceObject.z.string(),
-    purposeIds: external_zod_namespaceObject.z.array(external_zod_namespaceObject.z.string()),
-    metadata: external_zod_namespaceObject.z.record(external_zod_namespaceObject.z.string(), external_zod_namespaceObject.z.unknown()).nullish(),
-    policyId: external_zod_namespaceObject.z.string().optional(),
-    ipAddress: external_zod_namespaceObject.z.string().nullish(),
-    userAgent: external_zod_namespaceObject.z.string().nullish(),
-    status: consentStatusSchema.prefault('active'),
-    withdrawalReason: external_zod_namespaceObject.z.string().nullish(),
-    givenAt: external_zod_namespaceObject.z.date().prefault(()=>new Date()),
-    validUntil: external_zod_namespaceObject.z.date().nullish(),
-    isActive: external_zod_namespaceObject.z.boolean().prefault(true)
-});
-const consentPolicyTable = (0, schema_namespaceObject.table)('consentPolicy', {
-    id: (0, schema_namespaceObject.idColumn)('id', 'varchar(255)'),
-    version: (0, schema_namespaceObject.column)('version', 'string'),
-    type: (0, schema_namespaceObject.column)('type', 'string'),
-    name: (0, schema_namespaceObject.column)('name', 'string'),
-    effectiveDate: (0, schema_namespaceObject.column)('effectiveDate', 'timestamp'),
-    expirationDate: (0, schema_namespaceObject.column)('expirationDate', 'timestamp').nullable(),
-    content: (0, schema_namespaceObject.column)('content', 'string'),
-    contentHash: (0, schema_namespaceObject.column)('contentHash', 'string'),
-    isActive: (0, schema_namespaceObject.column)('isActive', 'bool').defaultTo$(()=>true),
-    createdAt: (0, schema_namespaceObject.column)('createdAt', 'timestamp').defaultTo$('now')
-});
-const PolicyTypeSchema = external_zod_namespaceObject.z["enum"]([
-    'cookie_banner',
-    'privacy_policy',
-    'dpa',
-    'terms_and_conditions',
-    'marketing_communications',
-    'age_verification',
-    'other'
-]);
-external_zod_namespaceObject.z.object({
-    id: external_zod_namespaceObject.z.string(),
-    version: external_zod_namespaceObject.z.string(),
-    type: PolicyTypeSchema,
-    name: external_zod_namespaceObject.z.string(),
-    effectiveDate: external_zod_namespaceObject.z.date(),
-    expirationDate: external_zod_namespaceObject.z.date().nullish(),
-    content: external_zod_namespaceObject.z.string(),
-    contentHash: external_zod_namespaceObject.z.string(),
-    isActive: external_zod_namespaceObject.z.boolean().prefault(true),
-    createdAt: external_zod_namespaceObject.z.date().prefault(()=>new Date())
-});
-const consentPurposeTable = (0, schema_namespaceObject.table)('consentPurpose', {
-    id: (0, schema_namespaceObject.idColumn)('id', 'varchar(255)'),
-    code: (0, schema_namespaceObject.column)('code', 'string'),
-    name: (0, schema_namespaceObject.column)('name', 'string'),
-    description: (0, schema_namespaceObject.column)("description", 'string'),
-    isEssential: (0, schema_namespaceObject.column)('isEssential', 'bool'),
-    dataCategory: (0, schema_namespaceObject.column)('dataCategory', 'string').nullable(),
-    legalBasis: (0, schema_namespaceObject.column)('legalBasis', 'string').nullable(),
-    isActive: (0, schema_namespaceObject.column)('isActive', 'bool').defaultTo$(()=>true),
-    createdAt: (0, schema_namespaceObject.column)('createdAt', 'timestamp').defaultTo$('now'),
-    updatedAt: (0, schema_namespaceObject.column)('updatedAt', 'timestamp').defaultTo$('now')
-});
-external_zod_namespaceObject.z.object({
-    id: external_zod_namespaceObject.z.string(),
-    code: external_zod_namespaceObject.z.string(),
-    name: external_zod_namespaceObject.z.string(),
-    description: external_zod_namespaceObject.z.string(),
-    isEssential: external_zod_namespaceObject.z.boolean(),
-    dataCategory: external_zod_namespaceObject.z.string().nullish(),
-    legalBasis: external_zod_namespaceObject.z.string().nullish(),
-    isActive: external_zod_namespaceObject.z.boolean().prefault(true),
-    createdAt: external_zod_namespaceObject.z.date().prefault(()=>new Date()),
-    updatedAt: external_zod_namespaceObject.z.date().prefault(()=>new Date())
-});
-const consentRecordTable = (0, schema_namespaceObject.table)('consentRecord', {
-    id: (0, schema_namespaceObject.idColumn)('id', 'varchar(255)'),
-    subjectId: (0, schema_namespaceObject.column)('subjectId', 'string'),
-    consentId: (0, schema_namespaceObject.column)('consentId', 'string').nullable(),
-    actionType: (0, schema_namespaceObject.column)('actionType', 'string'),
-    details: (0, schema_namespaceObject.column)('details', 'json').nullable(),
-    createdAt: (0, schema_namespaceObject.column)('createdAt', 'timestamp').defaultTo$('now')
-});
-external_zod_namespaceObject.z.object({
-    id: external_zod_namespaceObject.z.string(),
-    subjectId: external_zod_namespaceObject.z.string(),
-    consentId: external_zod_namespaceObject.z.string().nullish(),
-    actionType: external_zod_namespaceObject.z.string(),
-    details: external_zod_namespaceObject.z.record(external_zod_namespaceObject.z.string(), external_zod_namespaceObject.z.unknown()).nullish(),
-    createdAt: external_zod_namespaceObject.z.date().prefault(()=>new Date())
-});
-const domainTable = (0, schema_namespaceObject.table)('domain', {
-    id: (0, schema_namespaceObject.idColumn)('id', 'varchar(255)'),
-    name: (0, schema_namespaceObject.column)('name', 'string').unique(),
-    description: (0, schema_namespaceObject.column)("description", 'string').nullable(),
-    allowedOrigins: (0, schema_namespaceObject.column)('allowedOrigins', 'json').nullable(),
-    isVerified: (0, schema_namespaceObject.column)('isVerified', 'bool').defaultTo$(()=>true),
-    isActive: (0, schema_namespaceObject.column)('isActive', 'bool').defaultTo$(()=>true),
-    createdAt: (0, schema_namespaceObject.column)('createdAt', 'timestamp').defaultTo$('now'),
-    updatedAt: (0, schema_namespaceObject.column)('updatedAt', 'timestamp').defaultTo$('now')
-});
-external_zod_namespaceObject.z.object({
-    id: external_zod_namespaceObject.z.string(),
-    name: external_zod_namespaceObject.z.string(),
-    description: external_zod_namespaceObject.z.string().nullish(),
-    allowedOrigins: external_zod_namespaceObject.z.array(external_zod_namespaceObject.z.string()).nullish(),
-    isVerified: external_zod_namespaceObject.z.boolean().prefault(true),
-    isActive: external_zod_namespaceObject.z.boolean().prefault(true),
-    createdAt: external_zod_namespaceObject.z.date().prefault(()=>new Date()),
-    updatedAt: external_zod_namespaceObject.z.date().prefault(()=>new Date())
-});
-const subjectTable = (0, schema_namespaceObject.table)('subject', {
-    id: (0, schema_namespaceObject.idColumn)('id', 'varchar(255)'),
-    isIdentified: (0, schema_namespaceObject.column)('isIdentified', 'bool').defaultTo$(()=>false),
-    externalId: (0, schema_namespaceObject.column)('externalId', 'string').nullable(),
-    identityProvider: (0, schema_namespaceObject.column)('identityProvider', 'string').nullable(),
-    lastIpAddress: (0, schema_namespaceObject.column)('lastIpAddress', 'string').nullable(),
-    subjectTimezone: (0, schema_namespaceObject.column)('subjectTimezone', 'string').nullable(),
-    createdAt: (0, schema_namespaceObject.column)('createdAt', 'timestamp').defaultTo$('now'),
-    updatedAt: (0, schema_namespaceObject.column)('updatedAt', 'timestamp').defaultTo$('now')
-});
-external_zod_namespaceObject.z.object({
-    id: external_zod_namespaceObject.z.string(),
-    isIdentified: external_zod_namespaceObject.z.boolean().prefault(false),
-    externalId: external_zod_namespaceObject.z.string().nullish(),
-    identityProvider: external_zod_namespaceObject.z.string().nullish(),
-    lastIpAddress: external_zod_namespaceObject.z.string().optional(),
-    subjectTimezone: external_zod_namespaceObject.z.string().nullish(),
-    createdAt: external_zod_namespaceObject.z.date().prefault(()=>new Date()),
-    updatedAt: external_zod_namespaceObject.z.date().prefault(()=>new Date())
-});
-const v1 = (0, schema_namespaceObject.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()
-            })
-    }
-});
-(0, external_fumadb_namespaceObject.fumadb)({
-    namespace: 'c15t',
-    schemas: [
-        v1
-    ]
-});
-const baseConsentSchema = external_zod_namespaceObject.z.object({
-    subjectId: external_zod_namespaceObject.z.string().optional(),
-    externalSubjectId: external_zod_namespaceObject.z.string().optional(),
-    identityProvider: external_zod_namespaceObject.z.string().optional(),
-    domain: external_zod_namespaceObject.z.string(),
-    type: PolicyTypeSchema,
-    metadata: external_zod_namespaceObject.z.record(external_zod_namespaceObject.z.string(), external_zod_namespaceObject.z.unknown()).optional()
-});
-const cookieBannerSchema = baseConsentSchema.extend({
-    type: external_zod_namespaceObject.z.literal('cookie_banner'),
-    preferences: external_zod_namespaceObject.z.record(external_zod_namespaceObject.z.string(), external_zod_namespaceObject.z.boolean())
-});
-const policyBasedSchema = baseConsentSchema.extend({
-    type: external_zod_namespaceObject.z["enum"]([
-        'privacy_policy',
-        'dpa',
-        'terms_and_conditions'
-    ]),
-    policyId: external_zod_namespaceObject.z.string().optional(),
-    preferences: external_zod_namespaceObject.z.record(external_zod_namespaceObject.z.string(), external_zod_namespaceObject.z.boolean()).optional()
-});
-const otherConsentSchema = baseConsentSchema.extend({
-    type: external_zod_namespaceObject.z["enum"]([
-        'marketing_communications',
-        'age_verification',
-        'other'
-    ]),
-    preferences: external_zod_namespaceObject.z.record(external_zod_namespaceObject.z.string(), external_zod_namespaceObject.z.boolean()).optional()
-});
-const postConsentContract = contract_namespaceObject.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: external_zod_namespaceObject.z.object({
-            formErrors: external_zod_namespaceObject.z.array(external_zod_namespaceObject.z.string()),
-            fieldErrors: external_zod_namespaceObject.z.record(external_zod_namespaceObject.z.string(), external_zod_namespaceObject.z.array(external_zod_namespaceObject.z.string()))
-        }),
-        error: 'Invalid input parameters'
-    },
-    SUBJECT_CREATION_FAILED: {
-        status: 400,
-        data: external_zod_namespaceObject.z.object({
-            subjectId: external_zod_namespaceObject.z.string().optional(),
-            externalSubjectId: external_zod_namespaceObject.z.string().optional()
-        }),
-        error: 'Failed to create or find subject'
-    },
-    DOMAIN_CREATION_FAILED: {
-        status: 500,
-        data: external_zod_namespaceObject.z.object({
-            domain: external_zod_namespaceObject.z.string()
-        }),
-        error: 'Failed to create or find domain'
-    },
-    POLICY_NOT_FOUND: {
-        status: 404,
-        data: external_zod_namespaceObject.z.object({
-            policyId: external_zod_namespaceObject.z.string(),
-            type: external_zod_namespaceObject.z.string()
-        }),
-        error: 'Policy not found'
-    },
-    POLICY_INACTIVE: {
-        status: 409,
-        data: external_zod_namespaceObject.z.object({
-            policyId: external_zod_namespaceObject.z.string(),
-            type: external_zod_namespaceObject.z.string()
-        }),
-        error: 'Policy is not active'
-    },
-    POLICY_CREATION_FAILED: {
-        status: 500,
-        data: external_zod_namespaceObject.z.object({
-            type: external_zod_namespaceObject.z.string()
-        }),
-        error: 'Failed to create or find policy'
-    },
-    PURPOSE_CREATION_FAILED: {
-        status: 500,
-        data: external_zod_namespaceObject.z.object({
-            purposeCode: external_zod_namespaceObject.z.string()
-        }),
-        error: 'Failed to create consent purpose'
-    },
-    CONSENT_CREATION_FAILED: {
-        status: 500,
-        data: external_zod_namespaceObject.z.object({
-            subjectId: external_zod_namespaceObject.z.string(),
-            domain: external_zod_namespaceObject.z.string()
-        }),
-        error: 'Failed to create consent record'
-    }
-}).input(external_zod_namespaceObject.z.discriminatedUnion('type', [
-    cookieBannerSchema,
-    policyBasedSchema,
-    otherConsentSchema
-])).output(external_zod_namespaceObject.z.object({
-    id: external_zod_namespaceObject.z.string(),
-    subjectId: external_zod_namespaceObject.z.string().optional(),
-    externalSubjectId: external_zod_namespaceObject.z.string().optional(),
-    domainId: external_zod_namespaceObject.z.string(),
-    domain: external_zod_namespaceObject.z.string(),
-    type: PolicyTypeSchema,
-    status: external_zod_namespaceObject.z.string(),
-    recordId: external_zod_namespaceObject.z.string(),
-    metadata: external_zod_namespaceObject.z.record(external_zod_namespaceObject.z.string(), external_zod_namespaceObject.z.unknown()).optional(),
-    givenAt: external_zod_namespaceObject.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 = external_zod_namespaceObject.z["enum"]([
-    'GDPR',
-    'CH',
-    'BR',
-    'PIPEDA',
-    'AU',
-    'APPI',
-    'PIPA',
-    'NONE'
-]);
-const JurisdictionInfoSchema = external_zod_namespaceObject.z.object({
-    code: JurisdictionCodeSchema,
-    message: external_zod_namespaceObject.z.string()
-});
-const TitleDescriptionSchema = external_zod_namespaceObject.z.object({
-    title: external_zod_namespaceObject.z.string(),
-    description: external_zod_namespaceObject.z.string()
-});
-const CompleteTranslationsSchema = external_zod_namespaceObject.z.object({
-    common: external_zod_namespaceObject.z.object({
-        acceptAll: external_zod_namespaceObject.z.string(),
-        rejectAll: external_zod_namespaceObject.z.string(),
-        customize: external_zod_namespaceObject.z.string(),
-        save: external_zod_namespaceObject.z.string()
-    }),
-    cookieBanner: TitleDescriptionSchema,
-    consentManagerDialog: TitleDescriptionSchema,
-    consentTypes: external_zod_namespaceObject.z.object({
-        experience: TitleDescriptionSchema,
-        functionality: TitleDescriptionSchema,
-        marketing: TitleDescriptionSchema,
-        measurement: TitleDescriptionSchema,
-        necessary: TitleDescriptionSchema
-    }),
-    frame: external_zod_namespaceObject.z.object({
-        title: external_zod_namespaceObject.z.string(),
-        actionButton: external_zod_namespaceObject.z.string()
-    }),
-    legalLinks: external_zod_namespaceObject.z.object({
-        privacyPolicy: external_zod_namespaceObject.z.string(),
-        termsOfService: external_zod_namespaceObject.z.string(),
-        cookiePolicy: external_zod_namespaceObject.z.string()
-    })
-});
-const PartialTranslationsSchema = external_zod_namespaceObject.z.object({
-    common: external_zod_namespaceObject.z.object({
-        acceptAll: external_zod_namespaceObject.z.string().optional(),
-        rejectAll: external_zod_namespaceObject.z.string().optional(),
-        customize: external_zod_namespaceObject.z.string().optional(),
-        save: external_zod_namespaceObject.z.string().optional()
-    }).partial(),
-    cookieBanner: TitleDescriptionSchema.partial(),
-    consentManagerDialog: TitleDescriptionSchema.partial(),
-    consentTypes: external_zod_namespaceObject.z.object({
-        experience: TitleDescriptionSchema.partial(),
-        functionality: TitleDescriptionSchema.partial(),
-        marketing: TitleDescriptionSchema.partial(),
-        measurement: TitleDescriptionSchema.partial(),
-        necessary: TitleDescriptionSchema.partial()
-    }).partial(),
-    frame: external_zod_namespaceObject.z.object({
-        title: external_zod_namespaceObject.z.string().optional(),
-        actionButton: external_zod_namespaceObject.z.string().optional()
-    }).partial().optional(),
-    legalLinks: external_zod_namespaceObject.z.object({
-        privacyPolicy: external_zod_namespaceObject.z.string().optional(),
-        termsOfService: external_zod_namespaceObject.z.string().optional(),
-        cookiePolicy: external_zod_namespaceObject.z.string().optional()
-    }).partial().optional()
-});
-const TranslationsSchema = external_zod_namespaceObject.z.union([
-    CompleteTranslationsSchema,
-    PartialTranslationsSchema
-]);
-const showConsentBannerContract = contract_namespaceObject.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(external_zod_namespaceObject.z.object({
-    showConsentBanner: external_zod_namespaceObject.z.boolean(),
-    jurisdiction: JurisdictionInfoSchema,
-    location: external_zod_namespaceObject.z.object({
-        countryCode: external_zod_namespaceObject.z.string().nullable(),
-        regionCode: external_zod_namespaceObject.z.string().nullable()
-    }),
-    translations: external_zod_namespaceObject.z.object({
-        language: external_zod_namespaceObject.z.string(),
-        translations: TranslationsSchema
-    }),
-    branding: external_zod_namespaceObject.z["enum"](types_branding)
-}));
-const verifyConsentInputSchema = external_zod_namespaceObject.z.strictObject({
-    subjectId: external_zod_namespaceObject.z.string().optional(),
-    externalSubjectId: external_zod_namespaceObject.z.string().optional(),
-    domain: external_zod_namespaceObject.z.string(),
-    type: PolicyTypeSchema,
-    policyId: external_zod_namespaceObject.z.string().optional(),
-    preferences: external_zod_namespaceObject.z.array(external_zod_namespaceObject.z.string()).optional()
-});
-const verify_contract_consentSchema = external_zod_namespaceObject.z.looseObject({
-    id: external_zod_namespaceObject.z.string(),
-    purposeIds: external_zod_namespaceObject.z.array(external_zod_namespaceObject.z.string())
-});
-const verifyConsentContract = contract_namespaceObject.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: external_zod_namespaceObject.z.object({
-            formErrors: external_zod_namespaceObject.z.array(external_zod_namespaceObject.z.string()),
-            fieldErrors: external_zod_namespaceObject.z.record(external_zod_namespaceObject.z.string(), external_zod_namespaceObject.z.array(external_zod_namespaceObject.z.string()).optional())
-        }),
-        error: 'Invalid input parameters'
-    },
-    SUBJECT_NOT_FOUND: {
-        status: 404,
-        data: external_zod_namespaceObject.z.object({
-            subjectId: external_zod_namespaceObject.z.string().optional(),
-            externalSubjectId: external_zod_namespaceObject.z.string().optional()
-        }),
-        error: 'Subject not found'
-    },
-    DOMAIN_NOT_FOUND: {
-        status: 404,
-        data: external_zod_namespaceObject.z.object({
-            domain: external_zod_namespaceObject.z.string()
-        }),
-        error: 'Domain not found'
-    },
-    POLICY_NOT_FOUND: {
-        status: 404,
-        data: external_zod_namespaceObject.z.object({
-            policyId: external_zod_namespaceObject.z.string(),
-            type: external_zod_namespaceObject.z.string()
-        }),
-        error: 'Policy not found or invalid'
-    },
-    PURPOSES_NOT_FOUND: {
-        status: 404,
-        data: external_zod_namespaceObject.z.object({
-            preferences: external_zod_namespaceObject.z.array(external_zod_namespaceObject.z.string()),
-            foundPurposes: external_zod_namespaceObject.z.array(external_zod_namespaceObject.z.string())
-        }),
-        error: 'Could not find all specified purposes'
-    },
-    COOKIE_BANNER_PREFERENCES_REQUIRED: {
-        status: 400,
-        data: external_zod_namespaceObject.z.object({
-            type: external_zod_namespaceObject.z.literal('cookie_banner')
-        }),
-        error: 'Preferences are required for cookie banner consent'
-    },
-    NO_CONSENT_FOUND: {
-        status: 404,
-        data: external_zod_namespaceObject.z.object({
-            policyId: external_zod_namespaceObject.z.string(),
-            subjectId: external_zod_namespaceObject.z.string(),
-            domainId: external_zod_namespaceObject.z.string()
-        }),
-        error: 'No consent found for the given policy'
-    }
-}).input(verifyConsentInputSchema).output(external_zod_namespaceObject.z.object({
-    isValid: external_zod_namespaceObject.z.boolean(),
-    reasons: external_zod_namespaceObject.z.array(external_zod_namespaceObject.z.string()).optional(),
-    consent: verify_contract_consentSchema.optional()
-}));
-const consentContracts = {
-    post: postConsentContract,
-    showBanner: showConsentBannerContract,
-    verify: verifyConsentContract,
-    identify: identifyUserContract
-};
-const statusContract = contract_namespaceObject.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(external_zod_namespaceObject.z.object({
-    status: external_zod_namespaceObject.z["enum"]([
-        'ok',
-        'error'
-    ]),
-    version: external_zod_namespaceObject.z.string(),
-    timestamp: external_zod_namespaceObject.z.date(),
-    client: external_zod_namespaceObject.z.object({
-        ip: external_zod_namespaceObject.z.string().nullable(),
-        userAgent: external_zod_namespaceObject.z.string().nullable(),
-        region: external_zod_namespaceObject.z.object({
-            countryCode: external_zod_namespaceObject.z.string().nullable(),
-            regionCode: external_zod_namespaceObject.z.string().nullable()
-        })
-    })
-}));
-const metaContracts = {
-    status: statusContract
-};
-const config = {
-    consent: consentContracts,
-    meta: metaContracts
-};
-const os = (0, server_namespaceObject.implement)(config);
-const external_base_x_namespaceObject = require("base-x");
-var external_base_x_default = /*#__PURE__*/ __webpack_require__.n(external_base_x_namespaceObject);
-const prefixes = {
-    auditLog: 'log',
-    consent: 'cns',
-    consentPolicy: 'pol',
-    consentPurpose: 'pur',
-    consentRecord: 'rec',
-    domain: 'dom',
-    subject: 'sub'
-};
-const b58 = external_base_x_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 identifyUser = os.consent.identify.handler(async ({ input, context })=>{
-    const typedContext = context;
-    const { db, logger } = typedContext;
-    logger.info('Handling identify-user request');
-    const { consentId, externalId, identityProvider = 'external' } = input;
-    const consent = await db.findFirst('consent', {
-        where: (b)=>b('id', '=', consentId)
-    });
-    if (!consent) throw new server_namespaceObject.ORPCError('CONSENT_NOT_FOUND', {
-        data: {
-            consentId
-        }
-    });
-    await db.transaction(async (tx)=>{
-        const existingSubject = await tx.findFirst('subject', {
-            where: (b)=>b.and(b('externalId', '=', externalId), b('id', '!=', consent.subjectId))
-        });
-        if (existingSubject) {
-            const currentSubjectId = consent.subjectId;
-            const oldSubjectId = existingSubject.id;
-            logger.info('Merging subjects', {
-                currentSubjectId,
-                oldSubjectId,
-                externalId,
-                identityProvider
-            });
-            await tx.updateMany('consent', {
-                where: (b)=>b('subjectId', '=', currentSubjectId),
-                set: {
-                    subjectId: oldSubjectId
-                }
-            });
-            await tx.updateMany('consentRecord', {
-                where: (b)=>b('subjectId', '=', currentSubjectId),
-                set: {
-                    subjectId: oldSubjectId
-                }
-            });
-            await tx.updateMany('auditLog', {
-                where: (b)=>b('subjectId', '=', currentSubjectId),
-                set: {
-                    subjectId: oldSubjectId
-                }
-            });
-            await tx.deleteMany('subject', {
-                where: (b)=>b('id', '=', currentSubjectId)
-            });
-            await tx.create('auditLog', {
-                id: await generateUniqueId(tx, 'auditLog', typedContext),
-                subjectId: oldSubjectId,
-                entityType: 'consent',
-                entityId: consent.id,
-                actionType: 'identify_user',
-                ipAddress: typedContext.ipAddress || null,
-                userAgent: typedContext.userAgent || null,
-                eventTimezone: 'UTC',
-                metadata: {
-                    externalId,
-                    identityProvider,
-                    mergedFrom: currentSubjectId
-                }
-            });
-        } else {
-            await tx.updateMany('subject', {
-                where: (b)=>b('id', '=', consent.subjectId),
-                set: {
-                    externalId,
-                    identityProvider,
-                    isIdentified: true,
-                    updatedAt: new Date()
-                }
-            });
-            await tx.create('auditLog', {
-                id: await generateUniqueId(tx, 'auditLog', typedContext),
-                subjectId: consent.subjectId,
-                entityType: 'consent',
-                entityId: consent.id,
-                actionType: 'identify_user',
-                ipAddress: typedContext.ipAddress || null,
-                userAgent: typedContext.userAgent || null,
-                eventTimezone: 'UTC',
-                metadata: {
-                    externalId,
-                    identityProvider
-                }
-            });
-        }
-    });
-    return {
-        success: true
-    };
-});
-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, identityProvider, externalSubjectId, domain, metadata, preferences } = input;
-    logger.debug('Request parameters', {
-        type,
-        subjectId,
-        identityProvider,
-        externalSubjectId,
-        domain
-    });
-    try {
-        const subject = await registry.findOrCreateSubject({
-            subjectId,
-            externalSubjectId,
-            identityProvider,
-            ipAddress: typedContext.ipAddress
-        });
-        if (!subject) throw new server_namespaceObject.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 server_namespaceObject.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 server_namespaceObject.ORPCError('POLICY_NOT_FOUND', {
-                data: {
-                    policyId,
-                    type
-                }
-            });
-            if (!policy.isActive) throw new server_namespaceObject.ORPCError('POLICY_INACTIVE', {
-                data: {
-                    policyId,
-                    type
-                }
-            });
-        } else {
-            const policy = await typedContext.registry.findOrCreatePolicy(type);
-            if (!policy) throw new server_namespaceObject.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 server_namespaceObject.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,
-            identityProvider: subject.identityProvider ?? 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 server_namespaceObject.ORPCError) throw error;
-        throw new server_namespaceObject.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
-    };
-}
-const translations_namespaceObject = require("@c15t/translations");
-function isSupportedBaseLanguage(lang) {
-    return lang in translations_namespaceObject.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(translations_namespaceObject.baseTranslations);
-    const supportedCustomLanguages = Object.keys(customTranslations || {});
-    const supportedLanguages = [
-        ...supportedDefaultLanguages,
-        ...supportedCustomLanguages
-    ];
-    const preferredLanguage = getPreferredLanguage(acceptLanguage, supportedLanguages);
-    const base = isSupportedBaseLanguage(preferredLanguage) ? translations_namespaceObject.baseTranslations[preferredLanguage] : translations_namespaceObject.baseTranslations.en;
-    const custom = supportedCustomLanguages.includes(preferredLanguage) ? customTranslations?.[preferredLanguage] : {};
-    const translations = custom ? (0, translations_namespaceObject.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 server_namespaceObject.ORPCError('DOMAIN_NOT_FOUND', {
-            data: {
-                domain
-            }
-        });
-        const subject = await typedContext.registry.findOrCreateSubject({
-            subjectId,
-            externalSubjectId,
-            ipAddress: typedContext.ipAddress ?? 'unknown'
-        });
-        if (!subject) throw new server_namespaceObject.ORPCError('SUBJECT_NOT_FOUND', {
-            data: {
-                subjectId,
-                externalSubjectId
-            }
-        });
-        if ('cookie_banner' === type && (!preferences || 0 === preferences.length)) throw new server_namespaceObject.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 server_namespaceObject.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 server_namespaceObject.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 server_namespaceObject.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 server_namespaceObject.ORPCError) throw error;
-        throw new server_namespaceObject.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,
-    identify: identifyUser
-};
-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: "1.8.0",
-        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
-});
-exports.router = __webpack_exports__.router;
-for(var __webpack_i__ in __webpack_exports__)if (-1 === [
-    "router"
-].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
-Object.defineProperty(exports, '__esModule', {
-    value: true
-});