@c15t/backend 1.0.0 → 1.1.0-canary.0

package/dist/index.cjs

@@ -1,3706 +0,0 @@
-"use strict";
-var __webpack_modules__ = {
-    "../../node_modules/.pnpm/zod@3.24.2/node_modules/zod/lib/ZodError.js": function(__unused_webpack_module, exports1, __webpack_require__) {
-        exports1.ZodError = void 0;
-        const util_1 = __webpack_require__("../../node_modules/.pnpm/zod@3.24.2/node_modules/zod/lib/helpers/util.js");
-        util_1.util.arrayToEnum([
-            "invalid_type",
-            "invalid_literal",
-            "custom",
-            "invalid_union",
-            "invalid_union_discriminator",
-            "invalid_enum_value",
-            "unrecognized_keys",
-            "invalid_arguments",
-            "invalid_return_type",
-            "invalid_date",
-            "invalid_string",
-            "too_small",
-            "too_big",
-            "invalid_intersection_types",
-            "not_multiple_of",
-            "not_finite"
-        ]);
-        class ZodError extends Error {
-            get errors() {
-                return this.issues;
-            }
-            constructor(issues){
-                super();
-                this.issues = [];
-                this.addIssue = (sub)=>{
-                    this.issues = [
-                        ...this.issues,
-                        sub
-                    ];
-                };
-                this.addIssues = (subs = [])=>{
-                    this.issues = [
-                        ...this.issues,
-                        ...subs
-                    ];
-                };
-                const actualProto = new.target.prototype;
-                if (Object.setPrototypeOf) Object.setPrototypeOf(this, actualProto);
-                else this.__proto__ = actualProto;
-                this.name = "ZodError";
-                this.issues = issues;
-            }
-            format(_mapper) {
-                const mapper = _mapper || function(issue) {
-                    return issue.message;
-                };
-                const fieldErrors = {
-                    _errors: []
-                };
-                const processError = (error)=>{
-                    for (const issue of error.issues)if ("invalid_union" === issue.code) issue.unionErrors.map(processError);
-                    else if ("invalid_return_type" === issue.code) processError(issue.returnTypeError);
-                    else if ("invalid_arguments" === issue.code) processError(issue.argumentsError);
-                    else if (0 === issue.path.length) fieldErrors._errors.push(mapper(issue));
-                    else {
-                        let curr = fieldErrors;
-                        let i = 0;
-                        while(i < issue.path.length){
-                            const el = issue.path[i];
-                            const terminal = i === issue.path.length - 1;
-                            if (terminal) {
-                                curr[el] = curr[el] || {
-                                    _errors: []
-                                };
-                                curr[el]._errors.push(mapper(issue));
-                            } else curr[el] = curr[el] || {
-                                _errors: []
-                            };
-                            curr = curr[el];
-                            i++;
-                        }
-                    }
-                };
-                processError(this);
-                return fieldErrors;
-            }
-            static assert(value) {
-                if (!(value instanceof ZodError)) throw new Error(`Not a ZodError: ${value}`);
-            }
-            toString() {
-                return this.message;
-            }
-            get message() {
-                return JSON.stringify(this.issues, util_1.util.jsonStringifyReplacer, 2);
-            }
-            get isEmpty() {
-                return 0 === this.issues.length;
-            }
-            flatten(mapper = (issue)=>issue.message) {
-                const fieldErrors = {};
-                const formErrors = [];
-                for (const sub of this.issues)if (sub.path.length > 0) {
-                    fieldErrors[sub.path[0]] = fieldErrors[sub.path[0]] || [];
-                    fieldErrors[sub.path[0]].push(mapper(sub));
-                } else formErrors.push(mapper(sub));
-                return {
-                    formErrors,
-                    fieldErrors
-                };
-            }
-            get formErrors() {
-                return this.flatten();
-            }
-        }
-        exports1.ZodError = ZodError;
-        ZodError.create = (issues)=>{
-            const error = new ZodError(issues);
-            return error;
-        };
-    },
-    "../../node_modules/.pnpm/zod@3.24.2/node_modules/zod/lib/helpers/util.js": function(__unused_webpack_module, exports1) {
-        Object.defineProperty(exports1, "__esModule", {
-            value: true
-        });
-        exports1.getParsedType = exports1.ZodParsedType = exports1.objectUtil = exports1.util = void 0;
-        var util;
-        (function(util) {
-            util.assertEqual = (val)=>val;
-            function assertIs(_arg) {}
-            util.assertIs = assertIs;
-            function assertNever(_x) {
-                throw new Error();
-            }
-            util.assertNever = assertNever;
-            util.arrayToEnum = (items)=>{
-                const obj = {};
-                for (const item of items)obj[item] = item;
-                return obj;
-            };
-            util.getValidEnumValues = (obj)=>{
-                const validKeys = util.objectKeys(obj).filter((k)=>"number" != typeof obj[obj[k]]);
-                const filtered = {};
-                for (const k of validKeys)filtered[k] = obj[k];
-                return util.objectValues(filtered);
-            };
-            util.objectValues = (obj)=>util.objectKeys(obj).map(function(e) {
-                    return obj[e];
-                });
-            util.objectKeys = "function" == typeof Object.keys ? (obj)=>Object.keys(obj) : (object)=>{
-                const keys = [];
-                for(const key in object)if (Object.prototype.hasOwnProperty.call(object, key)) keys.push(key);
-                return keys;
-            };
-            util.find = (arr, checker)=>{
-                for (const item of arr)if (checker(item)) return item;
-            };
-            util.isInteger = "function" == typeof Number.isInteger ? (val)=>Number.isInteger(val) : (val)=>"number" == typeof val && isFinite(val) && Math.floor(val) === val;
-            function joinValues(array, separator = " | ") {
-                return array.map((val)=>"string" == typeof val ? `'${val}'` : val).join(separator);
-            }
-            util.joinValues = joinValues;
-            util.jsonStringifyReplacer = (_, value)=>{
-                if ("bigint" == typeof value) return value.toString();
-                return value;
-            };
-        })(util || (exports1.util = util = {}));
-        var objectUtil;
-        (function(objectUtil) {
-            objectUtil.mergeShapes = (first, second)=>({
-                    ...first,
-                    ...second
-                });
-        })(objectUtil || (exports1.objectUtil = objectUtil = {}));
-        exports1.ZodParsedType = util.arrayToEnum([
-            "string",
-            "nan",
-            "number",
-            "integer",
-            "float",
-            "boolean",
-            "date",
-            "bigint",
-            "symbol",
-            "function",
-            "undefined",
-            "null",
-            "array",
-            "object",
-            "unknown",
-            "promise",
-            "void",
-            "never",
-            "map",
-            "set"
-        ]);
-        const getParsedType = (data)=>{
-            const t = typeof data;
-            switch(t){
-                case "undefined":
-                    return exports1.ZodParsedType.undefined;
-                case "string":
-                    return exports1.ZodParsedType.string;
-                case "number":
-                    return isNaN(data) ? exports1.ZodParsedType.nan : exports1.ZodParsedType.number;
-                case "boolean":
-                    return exports1.ZodParsedType.boolean;
-                case "function":
-                    return exports1.ZodParsedType.function;
-                case "bigint":
-                    return exports1.ZodParsedType.bigint;
-                case "symbol":
-                    return exports1.ZodParsedType.symbol;
-                case "object":
-                    if (Array.isArray(data)) return exports1.ZodParsedType.array;
-                    if (null === data) return exports1.ZodParsedType.null;
-                    if (data.then && "function" == typeof data.then && data.catch && "function" == typeof data.catch) return exports1.ZodParsedType.promise;
-                    if ("undefined" != typeof Map && data instanceof Map) return exports1.ZodParsedType.map;
-                    if ("undefined" != typeof Set && data instanceof Set) return exports1.ZodParsedType.set;
-                    if ("undefined" != typeof Date && data instanceof Date) return exports1.ZodParsedType.date;
-                    return exports1.ZodParsedType.object;
-                default:
-                    return exports1.ZodParsedType.unknown;
-            }
-        };
-        exports1.getParsedType = getParsedType;
-    }
-};
-var __webpack_module_cache__ = {};
-function __webpack_require__(moduleId) {
-    var cachedModule = __webpack_module_cache__[moduleId];
-    if (void 0 !== cachedModule) return cachedModule.exports;
-    var module = __webpack_module_cache__[moduleId] = {
-        exports: {}
-    };
-    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
-    return module.exports;
-}
-(()=>{
-    __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__, {
-        Types: ()=>types_namespaceObject,
-        c15tInstance: ()=>c15tInstance
-    });
-    var types_namespaceObject = {};
-    __webpack_require__.r(types_namespaceObject);
-    const resources_namespaceObject = require("@opentelemetry/resources");
-    const sdk_node_namespaceObject = require("@opentelemetry/sdk-node");
-    const sdk_trace_base_namespaceObject = require("@opentelemetry/sdk-trace-base");
-    const external_defu_namespaceObject = require("defu");
-    function utils_applyDefaultValue(inputValue, field, operation) {
-        if ('update' === operation) return inputValue;
-        if (null == inputValue && field.defaultValue) {
-            if ('function' == typeof field.defaultValue) return field.defaultValue();
-            return field.defaultValue;
-        }
-        return inputValue;
-    }
-    const external_superjson_namespaceObject = require("superjson");
-    var external_superjson_default = /*#__PURE__*/ __webpack_require__.n(external_superjson_namespaceObject);
-    const COMMON_TIMEZONES = {
-        UTC: 'UTC',
-        GMT: 'GMT',
-        EASTERN: 'America/New_York',
-        CENTRAL: 'America/Chicago',
-        MOUNTAIN: 'America/Denver',
-        PACIFIC: 'America/Los_Angeles',
-        LONDON: 'Europe/London',
-        PARIS: 'Europe/Paris',
-        BERLIN: 'Europe/Berlin',
-        TOKYO: 'Asia/Tokyo',
-        SHANGHAI: 'Asia/Shanghai',
-        SINGAPORE: 'Asia/Singapore',
-        SYDNEY: 'Australia/Sydney',
-        SAO_PAULO: 'America/Sao_Paulo'
-    };
-    const external_base_x_namespaceObject = require("base-x");
-    var external_base_x_default = /*#__PURE__*/ __webpack_require__.n(external_base_x_namespaceObject);
-    const b58 = external_base_x_default()('123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz');
-    function id_generator_generateId(prefix) {
-        const buf = crypto.getRandomValues(new Uint8Array(20));
-        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)}`;
-    }
-    const external_zod_namespaceObject = require("zod");
-    const fieldConfigSchema = external_zod_namespaceObject.z.object({
-        required: external_zod_namespaceObject.z.boolean().default(true),
-        returned: external_zod_namespaceObject.z.boolean().default(true),
-        input: external_zod_namespaceObject.z.boolean().default(true),
-        defaultValue: external_zod_namespaceObject.z.union([
-            external_zod_namespaceObject.z.any(),
-            external_zod_namespaceObject.z["function"]().returns(external_zod_namespaceObject.z.any())
-        ]).optional(),
-        transform: external_zod_namespaceObject.z.object({
-            input: external_zod_namespaceObject.z["function"]().args(external_zod_namespaceObject.z.any()).returns(external_zod_namespaceObject.z.union([
-                external_zod_namespaceObject.z.any(),
-                external_zod_namespaceObject.z.promise(external_zod_namespaceObject.z.any())
-            ])).optional(),
-            output: external_zod_namespaceObject.z["function"]().args(external_zod_namespaceObject.z.any()).returns(external_zod_namespaceObject.z.union([
-                external_zod_namespaceObject.z.any(),
-                external_zod_namespaceObject.z.promise(external_zod_namespaceObject.z.any())
-            ])).optional()
-        }).optional(),
-        validator: external_zod_namespaceObject.z["function"]().args(external_zod_namespaceObject.z.any()).returns(external_zod_namespaceObject.z.union([
-            external_zod_namespaceObject.z.string(),
-            external_zod_namespaceObject.z["null"]()
-        ])).optional(),
-        unique: external_zod_namespaceObject.z.boolean().optional(),
-        indexed: external_zod_namespaceObject.z.boolean().optional(),
-        sortable: external_zod_namespaceObject.z.boolean().default(true),
-        fieldName: external_zod_namespaceObject.z.string().optional(),
-        bigint: external_zod_namespaceObject.z.boolean().default(false)
-    });
-    const stringFieldSchema = fieldConfigSchema.extend({
-        type: external_zod_namespaceObject.z.literal('string'),
-        minLength: external_zod_namespaceObject.z.number().optional(),
-        maxLength: external_zod_namespaceObject.z.number().optional(),
-        pattern: external_zod_namespaceObject.z.string().optional()
-    });
-    const numberFieldSchema = fieldConfigSchema.extend({
-        type: external_zod_namespaceObject.z.literal('number'),
-        min: external_zod_namespaceObject.z.number().optional(),
-        max: external_zod_namespaceObject.z.number().optional()
-    });
-    const booleanFieldSchema = fieldConfigSchema.extend({
-        type: external_zod_namespaceObject.z.literal('boolean')
-    });
-    const dateFieldSchema = fieldConfigSchema.extend({
-        type: external_zod_namespaceObject.z.literal('date'),
-        minDate: external_zod_namespaceObject.z.date().optional(),
-        maxDate: external_zod_namespaceObject.z.date().optional(),
-        dateOnly: external_zod_namespaceObject.z.boolean().default(false),
-        format: external_zod_namespaceObject.z.record(external_zod_namespaceObject.z.unknown()).optional()
-    });
-    const timezoneFieldSchema = fieldConfigSchema.extend({
-        type: external_zod_namespaceObject.z.literal('timezone'),
-        validateTimezone: external_zod_namespaceObject.z.boolean().default(true),
-        suggestedValues: external_zod_namespaceObject.z.array(external_zod_namespaceObject.z.string()).optional(),
-        restrictToSuggestedValues: external_zod_namespaceObject.z.boolean().default(false)
-    });
-    const jsonFieldSchema = fieldConfigSchema.extend({
-        type: external_zod_namespaceObject.z.literal('json'),
-        validateJson: external_zod_namespaceObject.z.boolean().default(true)
-    });
-    const stringArrayFieldSchema = fieldConfigSchema.extend({
-        type: external_zod_namespaceObject.z.literal('string[]')
-    });
-    const numberArrayFieldSchema = fieldConfigSchema.extend({
-        type: external_zod_namespaceObject.z.literal('number[]')
-    });
-    external_zod_namespaceObject.z.discriminatedUnion('type', [
-        stringFieldSchema,
-        numberFieldSchema,
-        booleanFieldSchema,
-        dateFieldSchema,
-        timezoneFieldSchema,
-        jsonFieldSchema,
-        stringArrayFieldSchema,
-        numberArrayFieldSchema
-    ]);
-    const external_neverthrow_namespaceObject = require("neverthrow");
-    const external_h3_namespaceObject = require("h3");
-    const error_codes_ERROR_CODES = Object.freeze({
-        NOT_FOUND: 'Resource not found',
-        BAD_REQUEST: 'Bad request',
-        CONFLICT: 'Conflict with current state',
-        MISSING_REQUIRED_PARAMETER: 'Missing required parameter',
-        UNAUTHORIZED: 'Unauthorized',
-        FORBIDDEN: 'Forbidden',
-        INTERNAL_SERVER_ERROR: 'Internal server error',
-        INITIALIZATION_FAILED: 'Initialization failed',
-        DATABASE_CONNECTION_ERROR: 'Database connection error',
-        DATABASE_QUERY_ERROR: 'Database query error',
-        INVALID_CONFIGURATION: 'Invalid configuration',
-        REQUEST_HANDLER_ERROR: 'Request handler error',
-        INVALID_REQUEST: 'Invalid request',
-        UNKNOWN_ERROR: 'Unknown error',
-        NETWORK_ERROR: 'Network error',
-        PLUGIN_INITIALIZATION_FAILED: 'Plugin initialization failed',
-        API_RETRIEVAL_ERROR: 'API retrieval error',
-        VALIDATION_ERROR: 'Validation error',
-        UNEXPECTED: 'Unexpected error'
-    });
-    const ERROR_CATEGORIES = Object.freeze({
-        VALIDATION: 'validation',
-        AUTHORIZATION: 'authorization',
-        STORAGE: 'storage',
-        NETWORK: 'network',
-        PLUGIN: 'plugin',
-        CONFIGURATION: 'configuration',
-        UNEXPECTED: 'unexpected'
-    });
-    const api_namespaceObject = require("@opentelemetry/api");
-    const tracing_tracer = api_namespaceObject.trace.getTracer('@doubletie/results');
-    async function tracing_withSpan(name, fn, attributes = {}) {
-        return await tracing_tracer.startActiveSpan(name, async (span)=>{
-            try {
-                span.setAttributes(attributes);
-                const result = await fn(span);
-                span.setStatus({
-                    code: api_namespaceObject.SpanStatusCode.OK
-                });
-                span.end();
-                return result;
-            } catch (error) {
-                if (error instanceof error_class_DoubleTieError) {
-                    span.setAttributes({
-                        'error.type': 'DoubleTieError',
-                        'error.code': error.code,
-                        'error.statusCode': error.statusCode,
-                        'error.message': error.message
-                    });
-                    if (error.meta) span.setAttributes({
-                        'error.meta': JSON.stringify(error.meta)
-                    });
-                } else span.setAttributes({
-                    'error.type': error instanceof Error ? error.constructor.name : 'Unknown',
-                    'error.message': error instanceof Error ? error.message : String(error)
-                });
-                span.setStatus({
-                    code: api_namespaceObject.SpanStatusCode.ERROR,
-                    message: error instanceof Error ? error.message : String(error)
-                });
-                span.end();
-                throw error;
-            }
-        });
-    }
-    class error_class_DoubleTieError extends external_h3_namespaceObject.H3Error {
-        code;
-        category;
-        meta;
-        constructor(message, options = {
-            code: error_codes_ERROR_CODES.UNKNOWN_ERROR,
-            status: 500,
-            category: ERROR_CATEGORIES.UNEXPECTED,
-            cause: void 0,
-            meta: {}
-        }){
-            super(message, {
-                cause: options.cause
-            });
-            this.name = this.constructor.name;
-            this.code = options.code ?? error_codes_ERROR_CODES.UNKNOWN_ERROR;
-            this.statusCode = options.status ?? 500;
-            this.category = options.category ?? ERROR_CATEGORIES.UNEXPECTED;
-            this.meta = options.meta ?? {};
-            this.data = {
-                code: this.code,
-                category: this.category,
-                meta: this.meta
-            };
-            tracing_withSpan('create_doubletie_error', async (span)=>{
-                span.setAttributes({
-                    'error.name': this.name,
-                    'error.message': message,
-                    'error.code': this.code,
-                    'error.status': this.statusCode,
-                    'error.category': this.category,
-                    'error.has_cause': !!this.cause,
-                    'error.cause_type': this.cause instanceof Error ? this.cause.constructor.name : typeof this.cause,
-                    'error.has_meta': !!this.meta
-                });
-                if (this.cause instanceof Error) span.recordException(this.cause);
-            });
-            if (Error.captureStackTrace) Error.captureStackTrace(this, this.constructor);
-        }
-        static isDoubleTieError(error) {
-            return error instanceof error_class_DoubleTieError;
-        }
-        toJSON() {
-            const validationErrorMessage = this.meta?.validationErrors ? String(this.meta.validationErrors) : void 0;
-            const stackTrace = this.stack ? this.stack.split('\n').map((line)=>line.trim()).filter((line)=>line && !line.includes('Error: ')) : [];
-            return {
-                statusCode: this.statusCode,
-                message: validationErrorMessage || this.message,
-                statusMessage: this.statusMessage,
-                data: {
-                    code: this.code,
-                    category: this.category,
-                    meta: this.meta,
-                    ...'production' === process.env.NODE_ENV ? {} : {
-                        stack: stackTrace
-                    },
-                    ...validationErrorMessage && this.message ? {
-                        originalMessage: this.message
-                    } : {},
-                    ...this.cause ? {
-                        cause: this.cause instanceof Error ? {
-                            name: this.cause.name,
-                            message: this.cause.message,
-                            stack: this.cause.stack ? this.cause.stack.split('\n').map((line)=>line.trim()) : void 0
-                        } : this.cause
-                    } : {}
-                }
-            };
-        }
-        static fromResponse(response, data) {
-            let message = `HTTP error ${response.status}`;
-            let errorCode = `HTTP ${response.status}`;
-            let errorMeta = {};
-            if (data && 'object' == typeof data && null !== data) {
-                const errorObj = data;
-                if ('string' == typeof errorObj.message) message = errorObj.message;
-                if ('string' == typeof errorObj.code) errorCode = errorObj.code;
-                if ('object' == typeof errorObj.data && null !== errorObj.data) errorMeta = errorObj.data;
-            }
-            return new error_class_DoubleTieError(message, {
-                code: errorCode,
-                status: response.status,
-                meta: errorMeta
-            });
-        }
-        withMeta(additionalMeta) {
-            return new error_class_DoubleTieError(this.message, {
-                code: this.code,
-                status: this.statusCode,
-                category: this.category,
-                cause: this.cause instanceof Error ? this.cause : void 0,
-                meta: {
-                    ...this.meta,
-                    ...additionalMeta
-                }
-            });
-        }
-        static createSubclass(name) {
-            const ErrorSubclass = class extends error_class_DoubleTieError {
-                constructor(message, options){
-                    super(message, options);
-                    this.name = name;
-                }
-            };
-            Object.defineProperty(ErrorSubclass, 'name', {
-                value: name
-            });
-            return ErrorSubclass;
-        }
-        static formatValidationError(error) {
-            if (!error.meta) return error.message;
-            let formattedMessage = `${error.message} (${error.code})`;
-            if (error.meta.validationErrors) formattedMessage += `\nValidation Errors: ${JSON.stringify(error.meta.validationErrors, null, 2)}`;
-            const otherMeta = Object.fromEntries(Object.entries(error.meta).filter(([key])=>'validationErrors' !== key));
-            if (Object.keys(otherMeta).length > 0) formattedMessage += `\nAdditional Context: ${JSON.stringify(otherMeta, null, 2)}`;
-            return formattedMessage;
-        }
-    }
-    function fail(message, options) {
-        const error = new error_class_DoubleTieError(message, options);
-        tracing_withSpan('create_error_result', async (span)=>{
-            span.setAttributes({
-                'error.message': message,
-                'error.code': options?.code,
-                'error.status': options?.status,
-                'error.category': options?.category
-            });
-        });
-        return (0, external_neverthrow_namespaceObject.err)(error);
-    }
-    function failAsync(message, options) {
-        const error = new error_class_DoubleTieError(message, options);
-        tracing_withSpan('create_error_result_async', async (span)=>{
-            span.setAttributes({
-                'error.message': message,
-                'error.code': options?.code,
-                'error.status': options?.status,
-                'error.category': options?.category
-            });
-        });
-        return (0, external_neverthrow_namespaceObject.errAsync)(error);
-    }
-    function promiseToResult(promise, errorCode = error_codes_ERROR_CODES.UNKNOWN_ERROR) {
-        return external_neverthrow_namespaceObject.ResultAsync.fromPromise(promise, (error)=>{
-            tracing_withSpan('promise_to_result', async (span)=>{
-                span.setAttributes({
-                    'operation.success': false,
-                    'error.type': error instanceof Error ? error.constructor.name : 'Unknown',
-                    'error.message': error instanceof Error ? error.message : String(error)
-                });
-            });
-            return new error_class_DoubleTieError(error instanceof Error ? error.message : String(error), {
-                code: errorCode,
-                cause: error instanceof Error ? error : void 0,
-                meta: {
-                    error
-                }
-            });
-        }).map((result)=>{
-            tracing_withSpan('promise_to_result', async (span)=>{
-                span.setAttributes({
-                    'operation.success': true,
-                    'result.type': typeof result
-                });
-            });
-            return result;
-        });
-    }
-    const validationPipeline = (schema, transformer)=>(data)=>{
-            const preprocessData = (value)=>{
-                if ('object' != typeof value || null === value) {
-                    if ('string' == typeof value) try {
-                        if (value.startsWith('[') && value.endsWith(']')) return JSON.parse(value);
-                        if ('true' === value.toLowerCase()) return true;
-                        if ('false' === value.toLowerCase()) return false;
-                        if (value.startsWith('{') && value.endsWith('}')) return JSON.parse(value);
-                    } catch  {}
-                    return value;
-                }
-                if (Array.isArray(value)) return value.map(preprocessData);
-                const processed = {};
-                for (const [key, val] of Object.entries(value))processed[key] = preprocessData(val);
-                return processed;
-            };
-            const preprocessedData = preprocessData(data);
-            const parseResult = schema.safeParse(preprocessedData);
-            if (!parseResult.success) return fail('Validation failed', {
-                code: error_codes_ERROR_CODES.INVALID_REQUEST,
-                status: 400,
-                meta: {
-                    validationErrors: parseResult.error.issues
-                }
-            });
-            try {
-                return (0, external_neverthrow_namespaceObject.ok)(transformer(parseResult.data));
-            } catch (error) {
-                return fail('Error transforming data after validation', {
-                    code: error_codes_ERROR_CODES.BAD_REQUEST,
-                    status: 400,
-                    cause: error instanceof Error ? error : void 0,
-                    meta: {
-                        inputData: parseResult.data
-                    }
-                });
-            }
-        };
-    function createH3ErrorHandler() {
-        return (0, external_h3_namespaceObject.eventHandler)((event)=>{
-            event.context._onError = (error)=>{
-                event.context.logger.error('Error in H3 error handler', {
-                    error
-                });
-                if (error instanceof error_class_DoubleTieError) {
-                    event.context.logger.error('Handling DoubleTieError:', error.statusCode, error.message);
-                    return (0, external_h3_namespaceObject.sendError)(event, error);
-                }
-                event.context.logger.error('Handling generic error', {
-                    error
-                });
-                const dtError = new error_class_DoubleTieError(error instanceof Error ? error.message : String(error), {
-                    code: error_codes_ERROR_CODES.INTERNAL_SERVER_ERROR,
-                    status: 500,
-                    cause: error instanceof Error ? error : void 0
-                });
-                return (0, external_h3_namespaceObject.sendError)(event, dtError);
-            };
-            event.node.req.on('error', (err)=>{
-                event.context.logger.error('Request error event triggered:', {
-                    err
-                });
-                if (event.context._onError) event.context._onError(err);
-            });
-        });
-    }
-    function withH3ErrorHandling(handler) {
-        return (0, external_h3_namespaceObject.eventHandler)(async (event)=>{
-            try {
-                return await handler(event);
-            } catch (error) {
-                event.context.logger.error('Error caught in withH3ErrorHandling:', {
-                    error
-                });
-                if (error instanceof error_class_DoubleTieError) {
-                    event.context.logger.error('Handling DoubleTieError in wrapper:', error.statusCode, error.message);
-                    return (0, external_h3_namespaceObject.sendError)(event, error);
-                }
-                if (event.context._onError && 'function' == typeof event.context._onError) return event.context._onError(error);
-                const dtError = new error_class_DoubleTieError(error instanceof Error ? error.message : String(error), {
-                    code: error_codes_ERROR_CODES.INTERNAL_SERVER_ERROR,
-                    status: 500,
-                    cause: error instanceof Error ? error : void 0
-                });
-                return (0, external_h3_namespaceObject.sendError)(event, dtError);
-            }
-        });
-    }
-    function createTelemetryOptions(appName = 'c15t', telemetryConfig) {
-        const serviceVersion = process.env.npm_package_version || '1.0.0';
-        const config = {
-            disabled: telemetryConfig?.disabled ?? false,
-            tracer: telemetryConfig?.tracer,
-            defaultAttributes: {
-                ...telemetryConfig?.defaultAttributes || {},
-                'service.name': String(appName),
-                'service.version': serviceVersion
-            }
-        };
-        return config;
-    }
-    var ZodError = __webpack_require__("../../node_modules/.pnpm/zod@3.24.2/node_modules/zod/lib/ZodError.js");
-    const colors = {
-        reset: '\x1b[0m',
-        bright: '\x1b[1m',
-        dim: '\x1b[2m',
-        underscore: '\x1b[4m',
-        blink: '\x1b[5m',
-        reverse: '\x1b[7m',
-        hidden: '\x1b[8m',
-        fg: {
-            black: '\x1b[30m',
-            red: '\x1b[31m',
-            green: '\x1b[32m',
-            yellow: '\x1b[33m',
-            blue: '\x1b[34m',
-            magenta: '\x1b[35m',
-            cyan: '\x1b[36m',
-            white: '\x1b[37m'
-        },
-        bg: {
-            black: '\x1b[40m',
-            red: '\x1b[41m',
-            green: '\x1b[42m',
-            yellow: '\x1b[43m',
-            blue: '\x1b[44m',
-            magenta: '\x1b[45m',
-            cyan: '\x1b[46m',
-            white: '\x1b[47m'
-        }
-    };
-    const levelColors = {
-        info: colors.fg.blue,
-        success: colors.fg.green,
-        warn: colors.fg.yellow,
-        error: colors.fg.red,
-        debug: colors.fg.magenta
-    };
-    const formatMessage = (level, message, appName = 'c15t')=>{
-        const timestamp = new Date().toISOString();
-        return `${colors.dim}${timestamp}${colors.reset} ${levelColors[level]}${level.toUpperCase()}${colors.reset} ${colors.bright}[${appName}]:${colors.reset} ${message}`;
-    };
-    const levels = [
-        'error',
-        'warn',
-        'info',
-        'success',
-        'debug'
-    ];
-    function shouldPublishLog(currentLogLevel, logLevel) {
-        const currentLevelIndex = levels.indexOf(currentLogLevel);
-        const messageLevelIndex = levels.indexOf(logLevel);
-        if ('debug' === currentLogLevel) return 'debug' === logLevel;
-        return messageLevelIndex <= currentLevelIndex;
-    }
-    const LOGGER_TRACER_NAME = '@doubletie/logger';
-    const LOG_LEVEL_TO_SPAN_STATUS = {
-        error: api_namespaceObject.SpanStatusCode.ERROR,
-        warn: api_namespaceObject.SpanStatusCode.OK,
-        info: api_namespaceObject.SpanStatusCode.OK,
-        success: api_namespaceObject.SpanStatusCode.OK,
-        debug: api_namespaceObject.SpanStatusCode.OK
-    };
-    const telemetry_getTracer = (options)=>{
-        if (options?.telemetry?.tracer) return options.telemetry.tracer;
-        return api_namespaceObject.trace.getTracer(LOGGER_TRACER_NAME);
-    };
-    const createLogSpan = (level, message, args = [], options)=>{
-        if (options?.telemetry?.disabled) return null;
-        const tracer = telemetry_getTracer(options);
-        const span = tracer.startSpan('log_entry', {
-            attributes: {
-                'log.level': level,
-                'log.message': message,
-                'log.has_args': args.length > 0,
-                ...options?.telemetry?.defaultAttributes || {}
-            }
-        });
-        if (args.length > 0 && 'object' == typeof args[0] && null !== args[0]) {
-            const data = args[0];
-            for (const [key, value] of Object.entries(data))if (null != value) span.setAttribute(`log.data.${key}`, String(value));
-        }
-        span.setStatus({
-            code: LOG_LEVEL_TO_SPAN_STATUS[level],
-            message: 'error' === level || 'warn' === level ? message : void 0
-        });
-        return span;
-    };
-    const withLogSpan = async (level, message, args, operation, options)=>{
-        const span = createLogSpan(level, message, args, options);
-        if (!span) return operation();
-        try {
-            const result = await operation();
-            return result;
-        } catch (error) {
-            span.setStatus({
-                code: api_namespaceObject.SpanStatusCode.ERROR,
-                message: error instanceof Error ? error.message : String(error)
-            });
-            throw error;
-        } finally{
-            span.end();
-        }
-    };
-    const createLogger = (options)=>{
-        if (options && 'object' == typeof options && levels.every((level)=>'function' == typeof options[level])) return options;
-        const loggerOptions = options;
-        const enabled = loggerOptions?.disabled !== true;
-        const logLevel = loggerOptions?.level ?? 'error';
-        const appName = loggerOptions?.appName ?? 'c15t';
-        const logFunc = async (level, message, args = [])=>{
-            if (!enabled || !shouldPublishLog(logLevel, level)) return;
-            await withLogSpan(level, message, args, async ()=>{
-                const formattedMessage = formatMessage(level, message, appName);
-                if (!loggerOptions || 'function' != typeof loggerOptions.log) {
-                    if ('error' === level) console.error(formattedMessage, ...args);
-                    else if ('warn' === level) console.warn(formattedMessage, ...args);
-                    else if ('info' === level) console.log(formattedMessage, ...args);
-                    else if ('debug' === level) console.debug(formattedMessage, ...args);
-                    else if ('success' === level) console.log(formattedMessage, ...args);
-                    return;
-                }
-                loggerOptions.log('success' === level ? 'info' : level, message, ...args);
-            });
-        };
-        return Object.fromEntries(levels.map((level)=>[
-                level,
-                (...[message, ...args])=>logFunc(level, message, args).catch((error)=>{
-                        console.error('Logger error:', error);
-                    })
-            ]));
-    };
-    const logger_factory_logger = createLogger();
-    const schema_auditLogSchema = 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.unknown()).optional(),
-        metadata: external_zod_namespaceObject.z.record(external_zod_namespaceObject.z.unknown()).optional(),
-        createdAt: external_zod_namespaceObject.z.date().default(()=>new Date())
-    });
-    function getAuditLogTable(options, auditLogFields) {
-        const auditLogConfig = options.tables?.auditLog;
-        const subjectConfig = options.tables?.subject;
-        return {
-            entityName: auditLogConfig?.entityName || 'auditLog',
-            entityPrefix: auditLogConfig?.entityPrefix || 'log',
-            schema: schema_auditLogSchema,
-            fields: {
-                entityType: {
-                    type: 'string',
-                    required: true,
-                    fieldName: auditLogConfig?.fields?.entityType || 'entityType'
-                },
-                entityId: {
-                    type: 'string',
-                    required: true,
-                    fieldName: auditLogConfig?.fields?.entityId || 'entityId'
-                },
-                actionType: {
-                    type: 'string',
-                    required: true,
-                    fieldName: auditLogConfig?.fields?.actionType || 'actionType'
-                },
-                subjectId: {
-                    type: 'string',
-                    required: false,
-                    fieldName: auditLogConfig?.fields?.subjectId || 'subjectId',
-                    references: {
-                        model: subjectConfig?.entityName || 'subject',
-                        field: 'id'
-                    }
-                },
-                ipAddress: {
-                    type: 'string',
-                    required: false,
-                    fieldName: auditLogConfig?.fields?.ipAddress || 'ipAddress'
-                },
-                userAgent: {
-                    type: 'string',
-                    required: false,
-                    fieldName: auditLogConfig?.fields?.userAgent || 'userAgent'
-                },
-                changes: {
-                    type: 'json',
-                    required: false,
-                    fieldName: auditLogConfig?.fields?.changes || 'changes'
-                },
-                metadata: {
-                    type: 'json',
-                    required: false,
-                    fieldName: auditLogConfig?.fields?.metadata || 'metadata'
-                },
-                createdAt: {
-                    type: 'date',
-                    defaultValue: ()=>new Date(),
-                    required: true,
-                    fieldName: auditLogConfig?.fields?.createdAt || 'createdAt'
-                },
-                eventTimezone: {
-                    type: 'timezone',
-                    required: true,
-                    defaultValue: COMMON_TIMEZONES.UTC,
-                    fieldName: auditLogConfig?.fields?.eventTimezone || 'eventTimezone'
-                },
-                ...auditLogFields || {},
-                ...auditLogConfig?.additionalFields || {}
-            },
-            indexes: [
-                {
-                    name: 'entity_index',
-                    fields: [
-                        'entityType',
-                        'entityId'
-                    ]
-                },
-                {
-                    name: 'action_type_index',
-                    fields: [
-                        'actionType'
-                    ]
-                },
-                {
-                    name: 'subject_id_index',
-                    fields: [
-                        'subjectId'
-                    ]
-                },
-                {
-                    name: 'created_at_index',
-                    fields: [
-                        'createdAt'
-                    ]
-                }
-            ],
-            order: 5
-        };
-    }
-    const PolicyTypeSchema = external_zod_namespaceObject.z["enum"]([
-        'cookie_banner',
-        'privacy_policy',
-        'dpa',
-        'terms_and_conditions',
-        'marketing_communications',
-        'age_verification',
-        'other'
-    ]);
-    const schema_consentPolicySchema = 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().nullable().optional(),
-        content: external_zod_namespaceObject.z.string(),
-        contentHash: external_zod_namespaceObject.z.string(),
-        isActive: external_zod_namespaceObject.z.boolean().default(true),
-        createdAt: external_zod_namespaceObject.z.date().default(()=>new Date()),
-        updatedAt: external_zod_namespaceObject.z.date().default(()=>new Date())
-    });
-    function getConsentPolicyTable(options, policyFields) {
-        const consentPolicyConfig = options.tables?.consentPolicy;
-        return {
-            entityName: consentPolicyConfig?.entityName || 'consentPolicy',
-            entityPrefix: consentPolicyConfig?.entityPrefix || 'pol',
-            schema: schema_consentPolicySchema,
-            fields: {
-                version: {
-                    type: 'string',
-                    required: true,
-                    fieldName: consentPolicyConfig?.fields?.version || 'version'
-                },
-                type: {
-                    type: 'string',
-                    required: true,
-                    fieldName: consentPolicyConfig?.fields?.type || 'type'
-                },
-                name: {
-                    type: 'string',
-                    required: true,
-                    fieldName: consentPolicyConfig?.fields?.name || 'name'
-                },
-                effectiveDate: {
-                    type: 'date',
-                    required: true,
-                    fieldName: consentPolicyConfig?.fields?.effectiveDate || 'effectiveDate'
-                },
-                expirationDate: {
-                    type: 'date',
-                    required: false,
-                    fieldName: consentPolicyConfig?.fields?.expirationDate || 'expirationDate'
-                },
-                content: {
-                    type: 'string',
-                    required: true,
-                    fieldName: consentPolicyConfig?.fields?.content || 'content'
-                },
-                contentHash: {
-                    type: 'string',
-                    required: true,
-                    fieldName: consentPolicyConfig?.fields?.contentHash || 'contentHash'
-                },
-                isActive: {
-                    type: 'boolean',
-                    defaultValue: true,
-                    required: true,
-                    fieldName: consentPolicyConfig?.fields?.isActive || 'isActive'
-                },
-                createdAt: {
-                    type: 'date',
-                    defaultValue: ()=>new Date(),
-                    required: true,
-                    fieldName: consentPolicyConfig?.fields?.createdAt || 'createdAt'
-                },
-                ...policyFields || {},
-                ...consentPolicyConfig?.additionalFields || {}
-            },
-            order: 2
-        };
-    }
-    const schema_purposeSchema = 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().default(false),
-        dataCategory: external_zod_namespaceObject.z.string().optional(),
-        legalBasis: external_zod_namespaceObject.z.string().optional(),
-        isActive: external_zod_namespaceObject.z.boolean().default(true),
-        createdAt: external_zod_namespaceObject.z.date().default(()=>new Date()),
-        updatedAt: external_zod_namespaceObject.z.date().default(()=>new Date())
-    });
-    function getPurposeTable(options, purposeFields) {
-        const purposeConfig = options.tables?.consentPurpose;
-        return {
-            entityName: purposeConfig?.entityName || 'consentPurpose',
-            entityPrefix: purposeConfig?.entityPrefix || 'pur',
-            schema: schema_purposeSchema,
-            fields: {
-                code: {
-                    type: 'string',
-                    required: true,
-                    fieldName: purposeConfig?.fields?.code || 'code'
-                },
-                name: {
-                    type: 'string',
-                    required: true,
-                    fieldName: purposeConfig?.fields?.name || 'name'
-                },
-                description: {
-                    type: 'string',
-                    required: true,
-                    fieldName: purposeConfig?.fields?.description || "description"
-                },
-                isEssential: {
-                    type: 'boolean',
-                    defaultValue: ()=>false,
-                    required: true,
-                    fieldName: purposeConfig?.fields?.isEssential || 'isEssential'
-                },
-                dataCategory: {
-                    type: 'string',
-                    required: false,
-                    fieldName: purposeConfig?.fields?.dataCategory || 'dataCategory'
-                },
-                legalBasis: {
-                    type: 'string',
-                    required: false,
-                    fieldName: purposeConfig?.fields?.legalBasis || 'legalBasis'
-                },
-                isActive: {
-                    type: 'boolean',
-                    defaultValue: true,
-                    required: true,
-                    fieldName: purposeConfig?.fields?.isActive || 'isActive'
-                },
-                createdAt: {
-                    type: 'date',
-                    defaultValue: ()=>new Date(),
-                    required: true,
-                    fieldName: purposeConfig?.fields?.createdAt || 'createdAt'
-                },
-                updatedAt: {
-                    type: 'date',
-                    defaultValue: ()=>new Date(),
-                    required: true,
-                    fieldName: purposeConfig?.fields?.updatedAt || 'updatedAt'
-                },
-                ...purposeFields || {},
-                ...purposeConfig?.additionalFields || {}
-            },
-            order: 1
-        };
-    }
-    const schema_consentRecordSchema = external_zod_namespaceObject.z.object({
-        id: external_zod_namespaceObject.z.string(),
-        subjectId: external_zod_namespaceObject.z.string(),
-        consentId: external_zod_namespaceObject.z.string().optional(),
-        actionType: external_zod_namespaceObject.z.string(),
-        details: external_zod_namespaceObject.z.record(external_zod_namespaceObject.z.unknown()).optional(),
-        createdAt: external_zod_namespaceObject.z.date().default(()=>new Date()),
-        updatedAt: external_zod_namespaceObject.z.date().default(()=>new Date())
-    });
-    function getConsentRecordTable(options, recordFields) {
-        const recordConfig = options.tables?.record;
-        const subjectConfig = options.tables?.subject;
-        const consentConfig = options.tables?.consent;
-        return {
-            entityName: recordConfig?.entityName || 'consentRecord',
-            entityPrefix: recordConfig?.entityPrefix || 'rec',
-            schema: schema_consentRecordSchema,
-            fields: {
-                subjectId: {
-                    type: 'string',
-                    required: true,
-                    fieldName: recordConfig?.fields?.subjectId || 'subjectId',
-                    references: {
-                        model: subjectConfig?.entityName || 'subject',
-                        field: 'id'
-                    }
-                },
-                consentId: {
-                    type: 'string',
-                    required: false,
-                    fieldName: recordConfig?.fields?.consentId || 'consentId',
-                    references: {
-                        model: consentConfig?.entityName || 'consent',
-                        field: 'id'
-                    }
-                },
-                actionType: {
-                    type: 'string',
-                    required: true,
-                    fieldName: recordConfig?.fields?.actionType || 'actionType'
-                },
-                details: {
-                    type: 'json',
-                    required: false,
-                    fieldName: recordConfig?.fields?.details || 'details'
-                },
-                createdAt: {
-                    type: 'date',
-                    defaultValue: ()=>new Date(),
-                    required: true,
-                    fieldName: recordConfig?.fields?.createdAt || 'createdAt'
-                },
-                ...recordFields || {},
-                ...recordConfig?.additionalFields || {}
-            },
-            order: 4
-        };
-    }
-    const schema_consentSchema = 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.unknown()).nullable().optional(),
-        policyId: external_zod_namespaceObject.z.string().optional(),
-        ipAddress: external_zod_namespaceObject.z.string().nullable().optional(),
-        userAgent: external_zod_namespaceObject.z.string().nullable().optional(),
-        status: external_zod_namespaceObject.z["enum"]([
-            'active',
-            'withdrawn',
-            'expired'
-        ]).default('active'),
-        withdrawalReason: external_zod_namespaceObject.z.string().nullable().optional(),
-        givenAt: external_zod_namespaceObject.z.date().default(()=>new Date()),
-        validUntil: external_zod_namespaceObject.z.date().nullable().optional(),
-        isActive: external_zod_namespaceObject.z.boolean().default(true)
-    });
-    function getConsentTable(options, consentFields) {
-        const consentConfig = options.tables?.consent;
-        const subjectConfig = options.tables?.subject;
-        const domainConfig = options.tables?.domain;
-        const policyConfig = options.tables?.consentPolicy;
-        return {
-            entityName: consentConfig?.entityName || 'consent',
-            entityPrefix: consentConfig?.entityPrefix || 'cns',
-            schema: schema_consentSchema,
-            fields: {
-                subjectId: {
-                    type: 'string',
-                    required: true,
-                    fieldName: consentConfig?.fields?.subjectId || 'subjectId',
-                    references: {
-                        model: subjectConfig?.entityName || 'subject',
-                        field: 'id'
-                    }
-                },
-                domainId: {
-                    type: 'string',
-                    required: true,
-                    fieldName: consentConfig?.fields?.domainId || 'domainId',
-                    references: {
-                        model: domainConfig?.entityName || 'domain',
-                        field: 'id'
-                    }
-                },
-                purposeIds: {
-                    type: 'json',
-                    required: false,
-                    fieldName: consentConfig?.fields?.purposeIds || 'purposeIds'
-                },
-                metadata: {
-                    type: 'json',
-                    required: false,
-                    fieldName: consentConfig?.fields?.metadata || 'metadata'
-                },
-                policyId: {
-                    type: 'string',
-                    required: false,
-                    fieldName: consentConfig?.fields?.policyId || 'policyId',
-                    references: {
-                        model: policyConfig?.entityName || 'consentPolicy',
-                        field: 'id'
-                    }
-                },
-                ipAddress: {
-                    type: 'string',
-                    required: false,
-                    fieldName: consentConfig?.fields?.ipAddress || 'ipAddress'
-                },
-                userAgent: {
-                    type: 'string',
-                    required: false,
-                    fieldName: consentConfig?.fields?.userAgent || 'userAgent'
-                },
-                status: {
-                    type: 'string',
-                    defaultValue: ()=>'active',
-                    required: true,
-                    fieldName: consentConfig?.fields?.status || 'status'
-                },
-                withdrawalReason: {
-                    type: 'string',
-                    required: false,
-                    fieldName: consentConfig?.fields?.withdrawalReason || 'withdrawalReason'
-                },
-                givenAt: {
-                    type: 'date',
-                    defaultValue: ()=>new Date(),
-                    required: true,
-                    fieldName: consentConfig?.fields?.givenAt || 'givenAt'
-                },
-                validUntil: {
-                    type: 'date',
-                    required: false,
-                    fieldName: consentConfig?.fields?.validUntil || 'validUntil',
-                    transform: {
-                        input: (val, data)=>{
-                            if (val) return val;
-                            const expiresIn = consentConfig?.expiresIn || 31536000;
-                            const givenAt = data.givenAt instanceof Date ? data.givenAt : new Date();
-                            if (expiresIn > 0) {
-                                const validUntil = new Date(givenAt);
-                                validUntil.setSeconds(validUntil.getSeconds() + expiresIn);
-                                return validUntil;
-                            }
-                        }
-                    }
-                },
-                isActive: {
-                    type: 'boolean',
-                    defaultValue: true,
-                    required: true,
-                    fieldName: consentConfig?.fields?.isActive || 'isActive'
-                },
-                ...consentFields || {},
-                ...consentConfig?.additionalFields || {}
-            },
-            order: 3
-        };
-    }
-    const schema_domainSchema = external_zod_namespaceObject.z.object({
-        id: external_zod_namespaceObject.z.string(),
-        name: external_zod_namespaceObject.z.string().min(1),
-        description: external_zod_namespaceObject.z.string().optional(),
-        allowedOrigins: external_zod_namespaceObject.z.array(external_zod_namespaceObject.z.string()).optional().default([]),
-        isVerified: external_zod_namespaceObject.z.boolean().default(true),
-        isActive: external_zod_namespaceObject.z.boolean().default(true),
-        createdAt: external_zod_namespaceObject.z.date().default(()=>new Date()),
-        updatedAt: external_zod_namespaceObject.z.date().default(()=>new Date())
-    });
-    function getDomainTable(options, domainFields) {
-        const domainConfig = options.tables?.domain;
-        return {
-            entityName: domainConfig?.entityName || 'domain',
-            entityPrefix: domainConfig?.entityPrefix || 'dom',
-            schema: schema_domainSchema,
-            fields: {
-                name: {
-                    type: 'string',
-                    required: true,
-                    unique: true,
-                    fieldName: domainConfig?.fields?.name || 'name'
-                },
-                description: {
-                    type: 'string',
-                    required: false,
-                    fieldName: domainConfig?.fields?.description || "description"
-                },
-                allowedOrigins: {
-                    type: 'json',
-                    defaultValue: ()=>[],
-                    required: false,
-                    fieldName: domainConfig?.fields?.allowedOrigins || 'allowedOrigins'
-                },
-                isVerified: {
-                    type: 'boolean',
-                    defaultValue: true,
-                    required: true,
-                    fieldName: domainConfig?.fields?.isVerified || 'isVerified'
-                },
-                isActive: {
-                    type: 'boolean',
-                    defaultValue: true,
-                    required: true,
-                    fieldName: domainConfig?.fields?.isActive || 'isActive'
-                },
-                createdAt: {
-                    type: 'date',
-                    defaultValue: ()=>new Date(),
-                    required: true,
-                    fieldName: domainConfig?.fields?.createdAt || 'createdAt'
-                },
-                updatedAt: {
-                    type: 'date',
-                    required: false,
-                    fieldName: domainConfig?.fields?.updatedAt || 'updatedAt'
-                },
-                ...domainFields || {},
-                ...domainConfig?.additionalFields || {}
-            },
-            order: 1
-        };
-    }
-    const schema_subjectSchema = external_zod_namespaceObject.z.object({
-        id: external_zod_namespaceObject.z.string(),
-        isIdentified: external_zod_namespaceObject.z.boolean().default(false),
-        externalId: external_zod_namespaceObject.z.string().nullable().optional(),
-        identityProvider: external_zod_namespaceObject.z.string().optional(),
-        lastIpAddress: external_zod_namespaceObject.z.string().optional(),
-        createdAt: external_zod_namespaceObject.z.date().default(()=>new Date()),
-        updatedAt: external_zod_namespaceObject.z.date().default(()=>new Date())
-    });
-    function getSubjectTable(options, subjectFields) {
-        const subjectConfig = options.tables?.subject;
-        return {
-            entityName: subjectConfig?.entityName || 'subject',
-            entityPrefix: subjectConfig?.entityPrefix || 'sub',
-            schema: schema_subjectSchema,
-            fields: {
-                isIdentified: {
-                    type: 'boolean',
-                    defaultValue: ()=>false,
-                    required: true,
-                    fieldName: subjectConfig?.fields?.isIdentified || 'isIdentified'
-                },
-                externalId: {
-                    type: 'string',
-                    required: false,
-                    fieldName: subjectConfig?.fields?.externalId || 'externalId'
-                },
-                identityProvider: {
-                    type: 'string',
-                    required: false,
-                    fieldName: subjectConfig?.fields?.identityProvider || 'identityProvider'
-                },
-                lastIpAddress: {
-                    type: 'string',
-                    required: false,
-                    fieldName: subjectConfig?.fields?.lastIpAddress || 'lastIpAddress'
-                },
-                createdAt: {
-                    type: 'date',
-                    defaultValue: ()=>new Date(),
-                    required: true,
-                    fieldName: subjectConfig?.fields?.createdAt || 'createdAt'
-                },
-                updatedAt: {
-                    type: 'date',
-                    defaultValue: ()=>new Date(),
-                    required: true,
-                    fieldName: subjectConfig?.fields?.updatedAt || 'updatedAt'
-                },
-                subjectTimezone: {
-                    type: 'timezone',
-                    required: false,
-                    defaultValue: COMMON_TIMEZONES.UTC,
-                    fieldName: subjectConfig?.fields?.subjectTimezone || 'subjectTimezone'
-                },
-                ...subjectFields || {},
-                ...subjectConfig?.additionalFields || {}
-            },
-            order: 1
-        };
-    }
-    const definition_getConsentTables = (options)=>{
-        const pluginSchema = options.plugins?.reduce((acc, plugin)=>{
-            const schema = plugin.schema;
-            if (!schema) return acc;
-            for (const [key, value] of Object.entries(schema))acc[key] = {
-                fields: {
-                    ...acc[key]?.fields,
-                    ...value.fields
-                },
-                entityName: key
-            };
-            return acc;
-        }, {});
-        const { subject, consentPurpose, consentPolicy, domain, geoLocation, consent, consentPurposeJunction, record, consentGeoLocation, consentWithdrawal, auditLog, ...pluginTables } = pluginSchema || {};
-        return {
-            subject: getSubjectTable(options, subject?.fields),
-            consentPurpose: getPurposeTable(options, consentPurpose?.fields),
-            consentPolicy: getConsentPolicyTable(options, consentPolicy?.fields),
-            domain: getDomainTable(options, domain?.fields),
-            consent: getConsentTable(options, consent?.fields),
-            consentRecord: getConsentRecordTable(options, record?.fields),
-            auditLog: getAuditLogTable(options, auditLog?.fields),
-            ...pluginTables
-        };
-    };
-    function validateEntityOutput(tableName, data, options) {
-        const tables = definition_getConsentTables(options);
-        const table = tables[tableName];
-        if (!table) throw new Error(`Table ${tableName} not found`);
-        const processedData = {
-            ...data
-        };
-        for (const [field, def] of Object.entries(table.fields))if ('date' === def.type && 'string' == typeof processedData[field]) processedData[field] = new Date(processedData[field]);
-        try {
-            return table.schema.parse(processedData);
-        } catch (error) {
-            if (error instanceof ZodError.ZodError) logger_factory_logger.error(`[validateEntityOutput] Validation failed for table ${String(tableName)}`, {
-                table,
-                issues: error.issues
-            });
-            throw error;
-        }
-    }
-    function subjectRegistry({ adapter, ...ctx }) {
-        const { createWithHooks } = getWithHooks(adapter, ctx);
-        return {
-            createSubject: async (subject, context)=>{
-                const createdSubject = await createWithHooks({
-                    data: {
-                        createdAt: new Date(),
-                        updatedAt: new Date(),
-                        ...subject
-                    },
-                    model: 'subject',
-                    customFn: void 0,
-                    context
-                });
-                return createdSubject ? validateEntityOutput('subject', createdSubject, ctx.options) : null;
-            },
-            findOrCreateSubject: async function({ subjectId, externalSubjectId, ipAddress = 'unknown', context }) {
-                if (subjectId && externalSubjectId) {
-                    const [subjectById, subjectByExternalId] = await Promise.all([
-                        this.findSubjectById(subjectId),
-                        this.findSubjectByExternalId(externalSubjectId)
-                    ]);
-                    if (!subjectById || !subjectByExternalId) {
-                        ctx.logger?.error('Subject validation failed: One or both subjects not found', {
-                            providedSubjectId: subjectId,
-                            providedExternalId: externalSubjectId,
-                            subjectByIdFound: !!subjectById,
-                            subjectByExternalIdFound: !!subjectByExternalId
-                        });
-                        throw new error_class_DoubleTieError('The specified subject could not be found. Please verify the subject identifiers and try again.', {
-                            code: error_codes_ERROR_CODES.NOT_FOUND,
-                            status: 404,
-                            meta: {
-                                providedSubjectId: subjectId,
-                                providedExternalId: externalSubjectId
-                            }
-                        });
-                    }
-                    if (subjectById.id !== subjectByExternalId.id) {
-                        ctx.logger?.warn('Subject validation failed: IDs do not match the same subject', {
-                            providedSubjectId: subjectId,
-                            providedExternalId: externalSubjectId,
-                            subjectByIdId: subjectById.id,
-                            subjectByExternalIdId: subjectByExternalId.id
-                        });
-                        throw new error_class_DoubleTieError('The provided subjectId and externalSubjectId do not match the same subject. Please ensure both identifiers refer to the same subject.', {
-                            code: error_codes_ERROR_CODES.CONFLICT,
-                            status: 409,
-                            meta: {
-                                providedSubjectId: subjectId,
-                                providedExternalId: externalSubjectId,
-                                subjectByIdId: subjectById.id,
-                                subjectByExternalIdId: subjectByExternalId.id
-                            }
-                        });
-                    }
-                    return subjectById;
-                }
-                if (subjectId) {
-                    const subject = await this.findSubjectById(subjectId);
-                    if (subject) return subject;
-                    throw new error_class_DoubleTieError('Subject not found by subjectId', {
-                        code: error_codes_ERROR_CODES.NOT_FOUND,
-                        status: 404
-                    });
-                }
-                if (externalSubjectId) try {
-                    const subject = await this.findSubjectByExternalId(externalSubjectId);
-                    if (subject) {
-                        ctx.logger?.debug('Found existing subject by external ID', {
-                            externalSubjectId
-                        });
-                        return subject;
-                    }
-                    ctx.logger?.info('Creating new subject with external ID', {
-                        externalSubjectId
-                    });
-                    return await this.createSubject({
-                        externalId: externalSubjectId,
-                        identityProvider: 'external',
-                        lastIpAddress: ipAddress,
-                        isIdentified: true
-                    }, context);
-                } catch (error) {
-                    if (error instanceof Error && error.message.includes('unique constraint')) {
-                        ctx.logger?.info('Handling duplicate key violation for external ID', {
-                            externalSubjectId
-                        });
-                        const subject = await this.findSubjectByExternalId(externalSubjectId);
-                        if (subject) return subject;
-                    }
-                    ctx.logger?.error('Failed to create or find subject with external ID', {
-                        externalSubjectId,
-                        error: error instanceof Error ? error.message : 'Unknown error'
-                    });
-                    throw new error_class_DoubleTieError('Failed to create or find subject with external ID', {
-                        code: error_codes_ERROR_CODES.INTERNAL_SERVER_ERROR,
-                        status: 500,
-                        meta: {
-                            error: error instanceof Error ? error.message : 'Unknown error'
-                        }
-                    });
-                }
-                try {
-                    ctx.logger?.info('Creating new anonymous subject');
-                    return await this.createSubject({
-                        externalId: null,
-                        identityProvider: 'anonymous',
-                        lastIpAddress: ipAddress,
-                        isIdentified: false
-                    }, context);
-                } catch (error) {
-                    ctx.logger?.error('Failed to create anonymous subject', {
-                        ipAddress,
-                        error: error instanceof Error ? error.message : 'Unknown error'
-                    });
-                    throw new error_class_DoubleTieError('Failed to create anonymous subject', {
-                        code: error_codes_ERROR_CODES.INTERNAL_SERVER_ERROR,
-                        status: 500,
-                        meta: {
-                            error: error instanceof Error ? error.message : 'Unknown error'
-                        }
-                    });
-                }
-            },
-            findSubjectById: async (subjectId)=>{
-                const subject = await adapter.findOne({
-                    model: 'subject',
-                    where: [
-                        {
-                            field: 'id',
-                            value: subjectId
-                        }
-                    ]
-                });
-                return subject ? validateEntityOutput('subject', subject, ctx.options) : null;
-            },
-            findSubjectByExternalId: async (externalId)=>{
-                const subject = await adapter.findOne({
-                    model: 'subject',
-                    where: [
-                        {
-                            field: 'externalId',
-                            value: externalId
-                        }
-                    ]
-                });
-                return subject ? validateEntityOutput('subject', subject, ctx.options) : null;
-            }
-        };
-    }
-    function consentRegistry({ adapter, ...ctx }) {
-        const { createWithHooks, updateWithHooks } = getWithHooks(adapter, ctx);
-        const registry = {
-            createConsent: async (consent, context)=>{
-                const createdConsent = await createWithHooks({
-                    data: {
-                        createdAt: new Date(),
-                        ...consent
-                    },
-                    model: 'consent',
-                    context
-                });
-                if (!createdConsent) throw new error_class_DoubleTieError('Failed to create consent - operation returned null', {
-                    code: error_codes_ERROR_CODES.INTERNAL_SERVER_ERROR,
-                    status: 500
-                });
-                return createdConsent;
-            },
-            updateConsent: async (consentId, data, context)=>{
-                const consent = await updateWithHooks({
-                    data: {
-                        ...data
-                    },
-                    where: [
-                        {
-                            field: 'id',
-                            value: consentId
-                        }
-                    ],
-                    model: 'consent',
-                    context
-                });
-                return consent ? validateEntityOutput('consent', consent, ctx.options) : null;
-            }
-        };
-        return registry;
-    }
-    const external_node_crypto_namespaceObject = require("node:crypto");
-    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()}`;
-        const contentHash = (0, external_node_crypto_namespaceObject.createHash)('sha256').update(content).digest('hex');
-        return {
-            content,
-            contentHash
-        };
-    }
-    function policyRegistry({ adapter, ...ctx }) {
-        const { createWithHooks } = getWithHooks(adapter, ctx);
-        const registry = {
-            createConsentPolicy: async (policy, context)=>{
-                const createdPolicy = await createWithHooks({
-                    data: {
-                        createdAt: new Date(),
-                        ...policy
-                    },
-                    model: 'consentPolicy',
-                    context
-                });
-                if (!createdPolicy) throw new error_class_DoubleTieError('Failed to create consent policy - operation returned null', {
-                    code: error_codes_ERROR_CODES.INTERNAL_SERVER_ERROR,
-                    status: 500
-                });
-                return createdPolicy;
-            },
-            findPolicies: async (params = {})=>{
-                const whereConditions = [];
-                if (!params.includeInactive) whereConditions.push({
-                    field: 'isActive',
-                    value: true
-                });
-                if (params.domainId) whereConditions.push({
-                    field: 'id',
-                    value: params.domainId
-                });
-                if (params.version) whereConditions.push({
-                    field: 'version',
-                    value: params.version
-                });
-                const policies = await adapter.findMany({
-                    model: 'consentPolicy',
-                    where: whereConditions,
-                    sortBy: {
-                        field: 'effectiveDate',
-                        direction: 'desc'
-                    }
-                });
-                return policies.map((policy)=>validateEntityOutput('consentPolicy', policy, ctx.options));
-            },
-            findConsentPolicyById: async (policyId)=>{
-                const policy = await adapter.findOne({
-                    model: 'consentPolicy',
-                    where: [
-                        {
-                            field: 'id',
-                            value: policyId
-                        }
-                    ]
-                });
-                return policy ? validateEntityOutput('consentPolicy', policy, ctx.options) : null;
-            },
-            findOrCreatePolicy: async (type)=>adapter.transaction({
-                    callback: async (txAdapter)=>{
-                        const now = new Date();
-                        const txRegistry = policyRegistry({
-                            adapter: txAdapter,
-                            ...ctx
-                        });
-                        const rawLatestPolicy = await txAdapter.findOne({
-                            model: 'consentPolicy',
-                            where: [
-                                {
-                                    field: 'isActive',
-                                    value: true
-                                },
-                                {
-                                    field: 'type',
-                                    value: type
-                                }
-                            ],
-                            sortBy: {
-                                field: 'effectiveDate',
-                                direction: 'desc'
-                            }
-                        });
-                        const latestPolicy = rawLatestPolicy ? validateEntityOutput('consentPolicy', rawLatestPolicy, ctx.options) : null;
-                        if (latestPolicy) return latestPolicy;
-                        const { content: defaultContent, contentHash } = generatePolicyPlaceholder(type, now);
-                        return txRegistry.createConsentPolicy({
-                            version: '1.0.0',
-                            type,
-                            name: type,
-                            effectiveDate: now,
-                            content: defaultContent,
-                            contentHash,
-                            isActive: true,
-                            updatedAt: now,
-                            expirationDate: null
-                        });
-                    }
-                })
-        };
-        return registry;
-    }
-    function consentPurposeRegistry({ adapter, ...ctx }) {
-        const { createWithHooks } = getWithHooks(adapter, ctx);
-        return {
-            createConsentPurpose: async (consentPurpose, context)=>{
-                const createdPurpose = await createWithHooks({
-                    data: {
-                        id: consentPurpose.id || '',
-                        createdAt: new Date(),
-                        updatedAt: new Date(),
-                        ...consentPurpose
-                    },
-                    model: 'consentPurpose',
-                    context
-                });
-                if (!createdPurpose) throw new error_class_DoubleTieError('Failed to create consent purpose - operation returned null', {
-                    code: error_codes_ERROR_CODES.INTERNAL_SERVER_ERROR,
-                    status: 500
-                });
-                return validateEntityOutput('consentPurpose', createdPurpose, ctx.options);
-            },
-            findConsentPurposeByCode: async (code)=>{
-                const consentPurpose = await adapter.findOne({
-                    model: 'consentPurpose',
-                    where: [
-                        {
-                            field: 'code',
-                            value: code
-                        }
-                    ]
-                });
-                return consentPurpose ? validateEntityOutput('consentPurpose', consentPurpose, ctx.options) : null;
-            }
-        };
-    }
-    function domainRegistry({ adapter, ...ctx }) {
-        const { createWithHooks } = getWithHooks(adapter, ctx);
-        const registry = {
-            createDomain: async (domain, context)=>{
-                const createdDomain = await createWithHooks({
-                    data: {
-                        ...domain,
-                        createdAt: new Date(),
-                        updatedAt: new Date()
-                    },
-                    model: 'domain',
-                    customFn: void 0,
-                    context
-                });
-                if (!createdDomain) throw new error_class_DoubleTieError('Failed to create domain - operation returned null', {
-                    code: error_codes_ERROR_CODES.INTERNAL_SERVER_ERROR,
-                    status: 500
-                });
-                return createdDomain;
-            },
-            findOrCreateDomain: async function(name, context) {
-                const existingDomain = await this.findDomainByName(name);
-                if (existingDomain) return existingDomain;
-                const domain = await this.createDomain({
-                    name,
-                    description: `Auto-created domain for ${name}`,
-                    isActive: true,
-                    isVerified: true,
-                    allowedOrigins: []
-                }, context);
-                if (!domain) throw new error_class_DoubleTieError('Failed to create domain', {
-                    code: error_codes_ERROR_CODES.INTERNAL_SERVER_ERROR,
-                    status: 503
-                });
-                return domain;
-            },
-            findDomains: async (params = {})=>{
-                const whereConditions = [];
-                if (!params.includeInactive) whereConditions.push({
-                    field: 'isActive',
-                    value: true
-                });
-                if (params.name) whereConditions.push({
-                    field: 'name',
-                    value: params.name
-                });
-                const domains = await adapter.findMany({
-                    model: 'domain',
-                    where: whereConditions,
-                    sortBy: {
-                        field: 'name',
-                        direction: 'asc'
-                    }
-                });
-                return domains.map((domain)=>validateEntityOutput('domain', domain, ctx.options));
-            },
-            findDomain: async (name)=>{
-                const domains = await registry.findDomains({
-                    name,
-                    includeInactive: false
-                });
-                return domains[0] || null;
-            },
-            findDomainByName: async (name)=>{
-                const domain = await adapter.findOne({
-                    model: 'domain',
-                    where: [
-                        {
-                            field: 'name',
-                            value: name
-                        }
-                    ]
-                });
-                return domain ? validateEntityOutput('domain', domain, ctx.options) : null;
-            }
-        };
-        return registry;
-    }
-    function auditLogRegistry({ adapter, ...ctx }) {
-        const { createWithHooks } = getWithHooks(adapter, ctx);
-        return {
-            createAuditLog: async (auditLog, context)=>{
-                const createdLog = await createWithHooks({
-                    data: {
-                        createdAt: new Date(),
-                        ...auditLog
-                    },
-                    model: 'auditLog',
-                    customFn: void 0,
-                    context
-                });
-                if (!createdLog) throw new error_class_DoubleTieError('Failed to create audit log - operation returned null', {
-                    code: error_codes_ERROR_CODES.INTERNAL_SERVER_ERROR,
-                    status: 500
-                });
-                return createdLog;
-            }
-        };
-    }
-    async function processHooks(data, model, operation, phase, hooks, context) {
-        let currentData = {
-            ...data
-        };
-        for (const hookSet of hooks){
-            const modelHooks = hookSet[model];
-            if (!modelHooks) continue;
-            const operationHooks = modelHooks[operation];
-            if (!operationHooks) continue;
-            const hookFn = operationHooks[phase];
-            if (hookFn) if ('before' === phase) {
-                const result = await hookFn(currentData, context);
-                if (result && 'object' == typeof result && 'kind' in result) switch(result.kind){
-                    case 'abort':
-                        return null;
-                    case 'transform':
-                        {
-                            const transformData = result.data;
-                            currentData = {
-                                ...currentData,
-                                ...transformData
-                            };
-                            break;
-                        }
-                    default:
-                        break;
-                }
-            } else await hookFn(currentData, context);
-        }
-        return currentData;
-    }
-    async function processAfterHooksForMany(records, model, hooks, context) {
-        if (!records.length) return;
-        for (const record of records)await processHooks(record, model, 'update', 'after', hooks, context);
-    }
-    async function create_hooks_createWithHooks(adapter, ctx, props) {
-        const { data, model, customFn, context } = props;
-        const hooks = ctx.hooks || [];
-        const transformedData = await processHooks(data, model, 'create', 'before', hooks, context);
-        if (null === transformedData) return null;
-        let created = null;
-        if (customFn) {
-            created = await customFn.fn(transformedData);
-            if (!customFn.executeMainFn && created) return created;
-        }
-        if (!created) created = await adapter.create({
-            model: model,
-            data: transformedData
-        });
-        if (created) await processHooks(created, model, 'create', 'after', hooks, context);
-        return created;
-    }
-    async function update_hooks_updateWithHooks(adapter, ctx, props) {
-        const { data, where, model, customFn, context } = props;
-        const hooks = ctx.hooks || [];
-        const transformedData = await processHooks(data, model, 'update', 'before', hooks, context);
-        if (null === transformedData) return null;
-        let updated = null;
-        if (customFn) {
-            const result = await customFn.fn(transformedData);
-            updated = result;
-            if (!customFn.executeMainFn && updated) return updated;
-        }
-        if (!updated) updated = await adapter.update({
-            model: model,
-            update: transformedData,
-            where
-        });
-        if (updated) await processHooks(updated, model, 'update', 'after', hooks, context);
-        return updated;
-    }
-    async function executeCustomFunction(data, customFn) {
-        if (!customFn) return {
-            result: null,
-            shouldContinue: true
-        };
-        const result = await customFn.fn(data);
-        const shouldContinue = !result || !!customFn.executeMainFn;
-        return {
-            result,
-            shouldContinue
-        };
-    }
-    function processUpdateManyResult(result) {
-        if (Array.isArray(result)) return result;
-        if ('number' == typeof result && result > 0) return [];
-        return null;
-    }
-    async function updateManyWithHooks(adapter, ctx, props) {
-        const { data, where, model, customFn, context } = props;
-        const hooks = ctx.hooks || [];
-        const transformedData = await processHooks(data, model, 'update', 'before', hooks, context);
-        if (null === transformedData) return null;
-        const { result: customResult, shouldContinue } = await executeCustomFunction(transformedData, customFn);
-        if (customResult && !shouldContinue) return customResult;
-        let updated = customResult;
-        if (!updated) {
-            const adapterResult = await adapter.updateMany({
-                model: model,
-                update: transformedData,
-                where
-            });
-            updated = processUpdateManyResult(adapterResult);
-        }
-        if (updated && updated.length > 0) await processAfterHooksForMany(updated, model, hooks, context);
-        return updated;
-    }
-    function getWithHooks(adapter, ctx) {
-        return {
-            createWithHooks: ({ data, model, customFn, context })=>create_hooks_createWithHooks(adapter, ctx, {
-                    data,
-                    model,
-                    customFn,
-                    context
-                }),
-            updateWithHooks: (props)=>update_hooks_updateWithHooks(adapter, ctx, props),
-            updateManyWithHooks: (props)=>updateManyWithHooks(adapter, ctx, props)
-        };
-    }
-    const createEntityTransformer = (db, options, config)=>{
-        const schema = definition_getConsentTables(options);
-        function getField(model, field) {
-            if ('id' === field) return field;
-            const modelFields = schema[model]?.fields;
-            const f = modelFields ? modelFields[field] : void 0;
-            if (!f) console.log('Field not found', model, field);
-            return f?.fieldName || field;
-        }
-        function transformValueToDB(value, model, field) {
-            if ('id' === field) return value;
-            const { type = 'sqlite' } = config || {};
-            const modelFields = schema[model]?.fields;
-            const f = modelFields ? modelFields[field] : void 0;
-            if (f?.type === 'boolean' && ('sqlite' === type || 'mssql' === type) && null != value) return value ? 1 : 0;
-            if (f?.type === 'date' && value && value instanceof Date) return 'sqlite' === type ? value.toISOString() : value;
-            if (f?.type === 'json' && null != value) {
-                if ('postgres' === type || 'mysql' === type) return value;
-                return external_superjson_default().stringify(value);
-            }
-            return value;
-        }
-        function transformValueFromDB(value, model, field) {
-            const { type = 'sqlite' } = config || {};
-            const modelFields = schema[model]?.fields;
-            const f = modelFields ? modelFields[field] : void 0;
-            if (f?.type === 'boolean' && ('sqlite' === type || 'mssql' === type) && null !== value) return 1 === value;
-            if (f?.type === 'date' && value) return new Date(value);
-            if (f?.type === 'json' && null != value) {
-                if (('postgres' === type || 'mysql' === type) && 'object' == typeof value) return value;
-                if ('string' == typeof value) try {
-                    return external_superjson_default().parse(value);
-                } catch  {
-                    try {
-                        return JSON.parse(value);
-                    } catch  {}
-                }
-            }
-            return value;
-        }
-        function getEntityName(model) {
-            return schema[model].entityName;
-        }
-        return {
-            transformInput (data, model, action) {
-                const transformedData = {};
-                if ('create' === action) {
-                    const advancedOptions = options.advanced || {};
-                    transformedData.id = data.id || (advancedOptions.generateId ? advancedOptions.generateId({
-                        model
-                    }) : id_generator_generateId(schema[model].entityPrefix));
-                }
-                const fields = schema[model].fields;
-                for(const field in fields)if (Object.hasOwn(fields, field)) {
-                    const value = data[field];
-                    const fieldInfo = fields[field];
-                    const fieldName = fieldInfo?.fieldName || field;
-                    if (fieldInfo) transformedData[fieldName] = utils_applyDefaultValue(transformValueToDB(value, model, field), fieldInfo, action);
-                }
-                return transformedData;
-            },
-            transformOutput (data, model, select = []) {
-                if (!data) return null;
-                const transformedData = {};
-                if (data.id && (0 === select.length || select.includes('id'))) transformedData.id = data.id;
-                const tableSchema = schema[model]?.fields;
-                for(const key in tableSchema){
-                    if (select.length && !select.includes(key)) continue;
-                    const field = tableSchema[key];
-                    if (field) transformedData[key] = transformValueFromDB(data[field.fieldName || key], model, key);
-                }
-                return transformedData;
-            },
-            convertWhereClause (model, whereConditions) {
-                if (!whereConditions || 0 === whereConditions.length) return {
-                    and: null,
-                    or: null
-                };
-                const conditions = {
-                    and: [],
-                    or: []
-                };
-                for (const condition of whereConditions){
-                    let { field: _field, value, operator = '=', connector = 'AND' } = condition;
-                    const fieldString = getField(model, _field);
-                    value = transformValueToDB(value, model, _field);
-                    const expr = (eb)=>{
-                        const dbField = fieldString;
-                        if ('in' === operator.toLowerCase()) return eb(dbField, 'in', Array.isArray(value) ? value : [
-                            value
-                        ]);
-                        if ('contains' === operator) return eb(dbField, 'like', `%${value}%`);
-                        if ('starts_with' === operator) return eb(dbField, 'like', `${value}%`);
-                        if ('ends_with' === operator) return eb(dbField, 'like', `%${value}`);
-                        if ('ilike' === operator) {
-                            const lowerField = eb.fn('lower', [
-                                dbField
-                            ]);
-                            const lowerValue = eb.fn('lower', [
-                                eb.val(value?.toString())
-                            ]);
-                            return eb(lowerField, 'like', lowerValue);
-                        }
-                        if ('eq' === operator) return eb(dbField, '=', value);
-                        if ('ne' === operator) return eb(dbField, '<>', value);
-                        if ('gt' === operator) return eb(dbField, '>', value);
-                        if ('gte' === operator) return eb(dbField, '>=', value);
-                        if ('lt' === operator) return eb(dbField, '<', value);
-                        if ('lte' === operator) return eb(dbField, '<=', value);
-                        return eb(dbField, operator, value);
-                    };
-                    if ('OR' === connector) conditions.or.push(expr);
-                    else conditions.and.push(expr);
-                }
-                return {
-                    and: conditions.and.length ? conditions.and : null,
-                    or: conditions.or.length ? conditions.or : null
-                };
-            },
-            async withReturning (values, builder, model, where) {
-                let res = null;
-                if (config?.type === 'mysql') {
-                    await builder.execute();
-                    const whereCondition = where[0];
-                    const field = values.id ? 'id' : whereCondition?.field ?? 'id';
-                    const value = values[field] ?? whereCondition?.value;
-                    const fieldString = getField(model, field);
-                    res = await db.selectFrom(getEntityName(model)).selectAll().where((eb)=>eb(fieldString, '=', value)).executeTakeFirst();
-                    return res;
-                }
-                if (config?.type === 'mssql') {
-                    res = await builder.outputAll('inserted').executeTakeFirst();
-                    return res;
-                }
-                res = await builder.returningAll().executeTakeFirst();
-                return res;
-            },
-            getEntityName,
-            getField
-        };
-    };
-    const kyselyAdapter = (db, config)=>(opts)=>{
-            const { transformInput, withReturning, transformOutput, convertWhereClause, getEntityName, getField } = createEntityTransformer(db, opts, config);
-            return {
-                id: 'kysely',
-                async create (data) {
-                    const { model, data: values, select } = data;
-                    const transformed = transformInput(values, model, 'create');
-                    const tableName = getEntityName(model);
-                    const builder = db.insertInto(tableName).values(transformed);
-                    const result = await withReturning(transformed, builder, model, []);
-                    const output = transformOutput(result, model, select);
-                    return output;
-                },
-                async findOne (data) {
-                    const { model, where, select } = data;
-                    const whereArray = Array.isArray(where) ? where : [
-                        where
-                    ];
-                    const { and, or } = convertWhereClause(model, whereArray);
-                    const tableName = getEntityName(model);
-                    let query = db.selectFrom(tableName).selectAll();
-                    if (and) query = query.where((eb)=>{
-                        const conditions = and.map((expr)=>expr(eb));
-                        return eb.and(conditions);
-                    });
-                    if (or) query = query.where((eb)=>{
-                        const conditions = or.map((expr)=>expr(eb));
-                        return eb.or(conditions);
-                    });
-                    const res = await query.executeTakeFirst();
-                    if (!res) return null;
-                    return transformOutput(res, model, select);
-                },
-                async findMany (data) {
-                    const { model, where, limit, offset, sortBy } = data;
-                    const whereArray = where ? Array.isArray(where) ? where : [
-                        where
-                    ] : void 0;
-                    const { and, or } = convertWhereClause(model, whereArray);
-                    const tableName = getEntityName(model);
-                    let query = db.selectFrom(tableName);
-                    if (and) query = query.where((eb)=>{
-                        const conditions = and.map((expr)=>expr(eb));
-                        return eb.and(conditions);
-                    });
-                    if (or) query = query.where((eb)=>{
-                        const conditions = or.map((expr)=>expr(eb));
-                        return eb.or(conditions);
-                    });
-                    if (config?.type === 'mssql') {
-                        if (!offset) query = query.top(limit || 100);
-                    } else query = query.limit(limit || 100);
-                    if (sortBy) {
-                        const sortFieldString = getField(model, sortBy.field);
-                        query = query.orderBy(sortFieldString, sortBy.direction);
-                    }
-                    if (offset) if (config?.type === 'mssql') {
-                        if (!sortBy) query = query.orderBy('id');
-                        query = query.offset(offset).fetch(limit || 100);
-                    } else query = query.offset(offset);
-                    const res = await query.selectAll().execute();
-                    if (!res) return [];
-                    return res.map((r)=>transformOutput(r, model));
-                },
-                async update (data) {
-                    const { model, where, update: values } = data;
-                    const whereArray = Array.isArray(where) ? where : [
-                        where
-                    ];
-                    const { and, or } = convertWhereClause(model, whereArray);
-                    const transformedData = transformInput(values, model, 'update');
-                    const tableName = getEntityName(model);
-                    let query = db.updateTable(tableName).set(transformedData);
-                    if (and) query = query.where((eb)=>{
-                        const conditions = and.map((expr)=>expr(eb));
-                        return eb.and(conditions);
-                    });
-                    if (or) query = query.where((eb)=>{
-                        const conditions = or.map((expr)=>expr(eb));
-                        return eb.or(conditions);
-                    });
-                    const result = await withReturning(transformedData, query, model, whereArray);
-                    return transformOutput(result, model);
-                },
-                async updateMany (data) {
-                    const { model, where, update: values } = data;
-                    const whereArray = Array.isArray(where) ? where : [
-                        where
-                    ];
-                    const { and, or } = convertWhereClause(model, whereArray);
-                    const transformedData = transformInput(values, model, 'update');
-                    const tableName = getEntityName(model);
-                    let query = db.updateTable(tableName).set(transformedData);
-                    if (and) query = query.where((eb)=>{
-                        const conditions = and.map((expr)=>expr(eb));
-                        return eb.and(conditions);
-                    });
-                    if (or) query = query.where((eb)=>{
-                        const conditions = or.map((expr)=>expr(eb));
-                        return eb.or(conditions);
-                    });
-                    await query.execute();
-                    let selectQuery = db.selectFrom(tableName).selectAll();
-                    if (and) selectQuery = selectQuery.where((eb)=>{
-                        const conditions = and.map((expr)=>expr(eb));
-                        return eb.and(conditions);
-                    });
-                    if (or) selectQuery = selectQuery.where((eb)=>{
-                        const conditions = or.map((expr)=>expr(eb));
-                        return eb.or(conditions);
-                    });
-                    const fetchedResults = await selectQuery.execute();
-                    if (!fetchedResults || 0 === fetchedResults.length) return [];
-                    return fetchedResults.map((record)=>transformOutput(record, model));
-                },
-                async count (data) {
-                    const { model, where } = data;
-                    const whereArray = where ? Array.isArray(where) ? where : [
-                        where
-                    ] : void 0;
-                    const { and, or } = convertWhereClause(model, whereArray);
-                    const tableName = getEntityName(model);
-                    let query = db.selectFrom(tableName).select((eb)=>eb.fn.count('id').as('count'));
-                    if (and) query = query.where((eb)=>{
-                        const conditions = and.map((expr)=>expr(eb));
-                        return eb.and(conditions);
-                    });
-                    if (or) query = query.where((eb)=>{
-                        const conditions = or.map((expr)=>expr(eb));
-                        return eb.or(conditions);
-                    });
-                    const res = await query.execute();
-                    const count = res[0]?.count;
-                    return 'number' == typeof count ? count : 0;
-                },
-                async delete (data) {
-                    const { model, where } = data;
-                    const whereArray = Array.isArray(where) ? where : [
-                        where
-                    ];
-                    const { and, or } = convertWhereClause(model, whereArray);
-                    const tableName = getEntityName(model);
-                    let query = db.deleteFrom(tableName);
-                    if (and) query = query.where((eb)=>{
-                        const conditions = and.map((expr)=>expr(eb));
-                        return eb.and(conditions);
-                    });
-                    if (or) query = query.where((eb)=>{
-                        const conditions = or.map((expr)=>expr(eb));
-                        return eb.or(conditions);
-                    });
-                    await query.execute();
-                },
-                async deleteMany (data) {
-                    const { model, where } = data;
-                    const whereArray = Array.isArray(where) ? where : [
-                        where
-                    ];
-                    const { and, or } = convertWhereClause(model, whereArray);
-                    const tableName = getEntityName(model);
-                    let query = db.deleteFrom(tableName);
-                    if (and) query = query.where((eb)=>{
-                        const conditions = and.map((expr)=>expr(eb));
-                        return eb.and(conditions);
-                    });
-                    if (or) query = query.where((eb)=>{
-                        const conditions = or.map((expr)=>expr(eb));
-                        return eb.or(conditions);
-                    });
-                    const result = await query.execute();
-                    const count = result.length;
-                    return count;
-                },
-                async transaction (data) {
-                    const { callback } = data;
-                    const advancedOptions = opts.advanced || {};
-                    if (advancedOptions.disableTransactions) {
-                        const regularAdapter = kyselyAdapter(db, config)(opts);
-                        return await callback(regularAdapter);
-                    }
-                    try {
-                        return await db.transaction().execute(async (trx)=>{
-                            const transactionAdapter = kyselyAdapter(trx, config)(opts);
-                            return await callback(transactionAdapter);
-                        });
-                    } catch (error) {
-                        if (error instanceof Error && (error.message.includes('transactions are not supported') || error.message.toLowerCase().includes('no transaction support'))) {
-                            console.warn("Warning: Database transaction failed. If your database does not support transactions, you can disable this warning by setting opts.advanced.disableTransactions to true.");
-                            const regularAdapter = kyselyAdapter(db, config)(opts);
-                            return await callback(regularAdapter);
-                        }
-                        throw error;
-                    }
-                },
-                options: config
-            };
-        };
-    const external_kysely_namespaceObject = require("kysely");
-    function getDatabaseType(db) {
-        if (!db) return null;
-        if ('dialect' in db) return getDatabaseType(db.dialect);
-        if (db && 'object' == typeof db && 'createDriver' in db) {
-            if (db instanceof external_kysely_namespaceObject.SqliteDialect) return 'sqlite';
-            if (db instanceof external_kysely_namespaceObject.MysqlDialect) return 'mysql';
-            if (db instanceof external_kysely_namespaceObject.PostgresDialect) return 'postgres';
-            if (db instanceof external_kysely_namespaceObject.MssqlDialect) return 'mssql';
-        }
-        if (db && 'object' == typeof db && 'aggregate' in db) return 'sqlite';
-        if (db && 'object' == typeof db && 'getConnection' in db) return 'mysql';
-        if (db && 'object' == typeof db && 'connect' in db) return 'postgres';
-        return null;
-    }
-    const createKyselyAdapter = async (config)=>{
-        const db = config.database;
-        if (!db) return {
-            kysely: null,
-            databaseType: null
-        };
-        if (db && 'object' == typeof db && 'db' in db) {
-            const kyselyConfig = db;
-            return {
-                kysely: kyselyConfig.db,
-                databaseType: kyselyConfig.type
-            };
-        }
-        if (db && 'object' == typeof db && 'dialect' in db) {
-            const dialectConfig = db;
-            return {
-                kysely: new external_kysely_namespaceObject.Kysely({
-                    dialect: dialectConfig.dialect
-                }),
-                databaseType: dialectConfig.type
-            };
-        }
-        let dialect;
-        const databaseType = getDatabaseType(db);
-        if (db && 'object' == typeof db && 'createDriver' in db) dialect = db;
-        if (db && 'object' == typeof db && 'aggregate' in db) dialect = new external_kysely_namespaceObject.SqliteDialect({
-            database: db
-        });
-        if (db && 'object' == typeof db && 'getConnection' in db) dialect = new external_kysely_namespaceObject.MysqlDialect({
-            pool: db
-        });
-        if (db && 'object' == typeof db && 'connect' in db) dialect = new external_kysely_namespaceObject.PostgresDialect({
-            pool: db
-        });
-        return {
-            kysely: dialect ? new external_kysely_namespaceObject.Kysely({
-                dialect
-            }) : null,
-            databaseType
-        };
-    };
-    const memory_adapter_createEntityTransformer = (options)=>{
-        const schema = definition_getConsentTables(options);
-        function getField(model, field) {
-            if ('id' === field) return field;
-            const modelFields = schema[model]?.fields;
-            const f = modelFields ? modelFields[field] : void 0;
-            return f?.fieldName || field;
-        }
-        return {
-            transformInput (data, model, action) {
-                const advancedOptions = options.advanced || {};
-                const transformedData = 'update' === action ? {} : {
-                    id: advancedOptions.generateId ? advancedOptions.generateId({
-                        model
-                    }) : data.id || id_generator_generateId(schema[model].entityPrefix)
-                };
-                const fields = schema[model].fields;
-                for(const field in fields)if (Object.hasOwn(fields, field)) {
-                    const value = data[field];
-                    const fieldInfo = fields[field];
-                    if (void 0 === value && !fieldInfo?.defaultValue) continue;
-                    const fieldName = fieldInfo?.fieldName || field;
-                    transformedData[fieldName] = utils_applyDefaultValue(value, fieldInfo, action);
-                }
-                return transformedData;
-            },
-            transformOutput (data, model, select = []) {
-                if (!data) return null;
-                const transformedData = {};
-                const hasId = data.id || data._id;
-                if (hasId && (0 === select.length || select.includes('id'))) transformedData.id = data.id;
-                const tableSchema = schema[model].fields;
-                for(const key in tableSchema){
-                    if (select.length && !select.includes(key)) continue;
-                    const field = tableSchema[key];
-                    if (field) transformedData[key] = data[field.fieldName || key];
-                }
-                return transformedData;
-            },
-            convertWhereClause (where, table, model) {
-                return table.filter((record)=>where.every((clause)=>{
-                        const { field: _field, value, operator = '=' } = clause;
-                        const field = getField(model, _field);
-                        if ('in' === operator) {
-                            if (!Array.isArray(value)) throw new Error('Value must be an array');
-                            return value.includes(record[field]);
-                        }
-                        if ('contains' === operator) {
-                            const fieldValue = record[field];
-                            return 'string' == typeof fieldValue && fieldValue.includes(value);
-                        }
-                        if ('starts_with' === operator) {
-                            const fieldValue = record[field];
-                            return 'string' == typeof fieldValue && fieldValue.startsWith(value);
-                        }
-                        if ('ends_with' === operator) {
-                            const fieldValue = record[field];
-                            return 'string' == typeof fieldValue && fieldValue.endsWith(value);
-                        }
-                        if ('eq' === operator) return record[field] === value;
-                        if ('ne' === operator) return record[field] !== value;
-                        return record[field] === value;
-                    }));
-            },
-            getField
-        };
-    };
-    const memoryAdapter = (db)=>(options)=>{
-            const { transformInput, transformOutput, convertWhereClause, getField } = memory_adapter_createEntityTransformer(options);
-            const schema = definition_getConsentTables(options);
-            for(const model in schema)if (!db[model]) db[model] = [];
-            return {
-                id: 'memory',
-                async create (data) {
-                    const { model, data: values, select } = data;
-                    const transformed = transformInput(values, model, 'create');
-                    if (!db[model]) db[model] = [];
-                    db[model].push(transformed);
-                    return transformOutput(transformed, model, select);
-                },
-                async findOne (data) {
-                    const { model, where, select } = data;
-                    const table = db[model] || [];
-                    const whereArray = Array.isArray(where) ? where : [
-                        where
-                    ];
-                    const res = convertWhereClause(whereArray, table, model);
-                    const record = res[0] || null;
-                    return transformOutput(record, model, select);
-                },
-                async findMany (data) {
-                    const { model, where, sortBy, limit, offset } = data;
-                    let table = db[model] || [];
-                    if (where) {
-                        const whereArray = Array.isArray(where) ? where : [
-                            where
-                        ];
-                        table = convertWhereClause(whereArray, table, model);
-                    }
-                    if (sortBy) {
-                        const field = getField(model, sortBy.field);
-                        table = [
-                            ...table
-                        ].sort((a, b)=>{
-                            if ('asc' === sortBy.direction) return a[field] > b[field] ? 1 : -1;
-                            return a[field] < b[field] ? 1 : -1;
-                        });
-                    }
-                    let result = table;
-                    if (void 0 !== offset) result = result.slice(offset);
-                    if (void 0 !== limit) result = result.slice(0, limit);
-                    return result.map((record)=>transformOutput(record, model));
-                },
-                async count (data) {
-                    const { model, where } = data;
-                    const table = db[model] || [];
-                    if (!where) return table.length;
-                    const whereArray = Array.isArray(where) ? where : [
-                        where
-                    ];
-                    const filtered = convertWhereClause(whereArray, table, model);
-                    return filtered.length;
-                },
-                async update (data) {
-                    const { model, where, update: values } = data;
-                    const table = db[model] || [];
-                    const whereArray = Array.isArray(where) ? where : [
-                        where
-                    ];
-                    const res = convertWhereClause(whereArray, table, model);
-                    for (const record of res)Object.assign(record, transformInput(values, model, 'update'));
-                    return transformOutput(res[0] || null, model);
-                },
-                async updateMany (data) {
-                    const { model, where, update: values } = data;
-                    const table = db[model] || [];
-                    const whereArray = Array.isArray(where) ? where : [
-                        where
-                    ];
-                    const res = convertWhereClause(whereArray, table, model);
-                    for (const record of res)Object.assign(record, transformInput(values, model, 'update'));
-                    return res.map((record)=>transformOutput(record, model));
-                },
-                async delete (data) {
-                    const { model, where } = data;
-                    const table = db[model] || [];
-                    const whereArray = Array.isArray(where) ? where : [
-                        where
-                    ];
-                    const res = convertWhereClause(whereArray, table, model);
-                    db[model] = table.filter((record)=>!res.includes(record));
-                },
-                async deleteMany (data) {
-                    const { model, where } = data;
-                    const table = db[model] || [];
-                    const whereArray = Array.isArray(where) ? where : [
-                        where
-                    ];
-                    const res = convertWhereClause(whereArray, table, model);
-                    let count = 0;
-                    db[model] = table.filter((record)=>{
-                        if (res.includes(record)) {
-                            count++;
-                            return false;
-                        }
-                        return true;
-                    });
-                    return count;
-                },
-                async transaction (data) {
-                    const { callback } = data;
-                    const tempDb = {};
-                    for(const key in db)if (Object.hasOwn(db, key)) tempDb[key] = JSON.parse(JSON.stringify(db[key]));
-                    const transactionAdapter = memoryAdapter(tempDb)(options);
-                    const result = await callback(transactionAdapter);
-                    for(const key in tempDb)if (Object.hasOwn(tempDb, key)) db[key] = tempDb[key];
-                    return result;
-                }
-            };
-        };
-    require("drizzle-orm");
-    async function getAdapter(options) {
-        const logger = createLogger({
-            appName: 'c15t'
-        });
-        if (!options.database) {
-            const tables = definition_getConsentTables(options);
-            const memoryDB = Object.keys(tables).reduce((acc, key)=>{
-                acc[key] = [];
-                return acc;
-            }, {});
-            logger.warn('No database configuration provided. Using memory adapter in development');
-            return memoryAdapter(memoryDB)(options);
-        }
-        if ('function' == typeof options.database) return options.database(options);
-        const { kysely, databaseType } = await createKyselyAdapter(options);
-        if (!kysely) throw new error_class_DoubleTieError('Failed to initialize database adapter', {
-            code: error_codes_ERROR_CODES.INTERNAL_SERVER_ERROR,
-            status: 500
-        });
-        return kyselyAdapter(kysely, {
-            type: databaseType || 'sqlite'
-        })(options);
-    }
-    const env = 'undefined' != typeof process ? process.env : {};
-    const isProduction = 'undefined' != typeof process && 'production' === process.env.NODE_ENV;
-    function toBoolean(val) {
-        return val ? 'false' !== val : false;
-    }
-    const nodeENV = 'undefined' != typeof process && process.env && process.env.NODE_ENV || '';
-    const isTest = 'test' === nodeENV || toBoolean(env.TEST);
-    const TRAILING_SLASHES_REGEX = /\/+$/;
-    function checkHasPath(url) {
-        try {
-            const parsedUrl = new URL(url);
-            return '/' !== parsedUrl.pathname;
-        } catch  {
-            throw new error_class_DoubleTieError(`Invalid base URL: ${url}. Please provide a valid base URL.`, {
-                code: error_codes_ERROR_CODES.BAD_REQUEST,
-                status: 400,
-                meta: {
-                    url
-                }
-            });
-        }
-    }
-    function withPath(url, path = '/api/auth') {
-        const hasPath = checkHasPath(url);
-        if (hasPath) return url;
-        const pathWithSlash = path.startsWith('/') ? path : `/${path}`;
-        return `${url.replace(TRAILING_SLASHES_REGEX, '')}${pathWithSlash}`;
-    }
-    function getBaseURL(url, path) {
-        if (url) return withPath(url, path);
-        const fromEnv = env.C15T_URL || env.NEXT_PUBLIC_C15T_URL || env.PUBLIC_C15T_URL || env.NUXT_PUBLIC_C15T_URL || env.NUXT_PUBLIC_AUTH_URL || ('/' !== env.BASE_URL ? env.BASE_URL : void 0);
-        if (fromEnv) return withPath(fromEnv, path);
-    }
-    const createRegistry = (ctx)=>({
-            ...auditLogRegistry(ctx),
-            ...consentRegistry(ctx),
-            ...domainRegistry(ctx),
-            ...consentPurposeRegistry(ctx),
-            ...policyRegistry(ctx),
-            ...subjectRegistry(ctx)
-        });
-    const DEFAULT_SECRET = 'c15t-default-secret-please-change-in-production';
-    let telemetrySdk;
-    const init = async (options)=>{
-        try {
-            const loggerOptions = options.logger;
-            const baseUrlStr = options.baseURL;
-            const basePathStr = options.basePath;
-            const databaseHooks = options.databaseHooks || [];
-            const appName = options.appName || 'c15t';
-            const logger = createLogger({
-                ...loggerOptions,
-                appName: String(appName)
-            });
-            const telemetryOptions = createTelemetryOptions(String(appName), options.telemetry);
-            let telemetryInitialized = false;
-            try {
-                if (telemetrySdk) {
-                    logger.debug('Telemetry SDK already initialized, skipping');
-                    telemetryInitialized = true;
-                } else if (telemetryOptions?.disabled) {
-                    logger.info('Telemetry is disabled by configuration');
-                    telemetryInitialized = false;
-                } else {
-                    const resource = new resources_namespaceObject.Resource({
-                        'service.name': String(appName),
-                        'service.version': String(process.env.npm_package_version || '1.0.0'),
-                        ...telemetryOptions?.defaultAttributes || {}
-                    });
-                    logger.debug('Initializing telemetry with resource attributes', {
-                        attributes: resource.attributes
-                    });
-                    const traceExporter = telemetryOptions?.tracer ? void 0 : new sdk_trace_base_namespaceObject.ConsoleSpanExporter();
-                    telemetrySdk = new sdk_node_namespaceObject.NodeSDK({
-                        resource,
-                        traceExporter
-                    });
-                    telemetrySdk.start();
-                    logger.info('Telemetry successfully initialized');
-                    telemetryInitialized = 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');
-                telemetryInitialized = false;
-            }
-            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');
-            logger.info('Initializing adapter', {
-                storage: options.storage && 'object' == typeof options.storage ? options.storage.type || 'unknown' : 'unknown',
-                clientVersion: options.clientVersion || 'not provided',
-                appName,
-                baseURL: baseUrlStr
-            });
-            const adapterResult = await promiseToResult(getAdapter(options), error_codes_ERROR_CODES.INITIALIZATION_FAILED);
-            logger.debug('Adapter initialization result', {
-                success: adapterResult.isOk()
-            });
-            return adapterResult.andThen((adapter)=>{
-                const resolvedBaseURL = getBaseURL(baseUrlStr, basePathStr);
-                const secret = options.secret || env.C15T_SECRET || env.CONSENT_SECRET || DEFAULT_SECRET;
-                if (secret === DEFAULT_SECRET && isProduction) logger.error('Using default secret in production. Set C15T_SECRET or pass secret in config.');
-                const finalOptions = {
-                    ...options,
-                    secret,
-                    baseURL: resolvedBaseURL ? new URL(resolvedBaseURL).origin : '',
-                    basePath: basePathStr || '/api/c15t',
-                    plugins: [
-                        ...options.plugins || [],
-                        ...getInternalPlugins(options)
-                    ],
-                    telemetry: telemetryOptions
-                };
-                const generateIdFunc = ({ model, size = 16 })=>finalOptions?.advanced?.generateId?.({
-                        model,
-                        size
-                    }) || id_generator_generateId(definition_getConsentTables(finalOptions)[model].entityPrefix);
-                const registryContext = {
-                    adapter,
-                    options: finalOptions,
-                    logger,
-                    hooks: databaseHooks,
-                    generateId: generateIdFunc
-                };
-                const ctx = {
-                    appName: String(appName),
-                    options: finalOptions,
-                    trustedOrigins: options.trustedOrigins || [],
-                    baseURL: resolvedBaseURL || '',
-                    secret,
-                    logger,
-                    generateId: generateIdFunc,
-                    adapter,
-                    registry: createRegistry(registryContext),
-                    tables: definition_getConsentTables(options)
-                };
-                return runPluginInit(ctx);
-            });
-        } catch (error) {
-            const errorLogger = createLogger(options.logger);
-            errorLogger.error('Initialization failed', {
-                error: error instanceof Error ? error.message : String(error),
-                stack: error instanceof Error ? error.stack : void 0
-            });
-            return failAsync(`Failed to initialize consent system: ${error instanceof Error ? error.message : String(error)}`, {
-                code: error_codes_ERROR_CODES.INITIALIZATION_FAILED,
-                meta: {
-                    error
-                }
-            });
-        }
-    };
-    function runPluginInit(ctx) {
-        try {
-            let options = ctx.options;
-            const plugins = options.plugins || [];
-            let context = ctx;
-            for (const plugin of plugins){
-                const typedPlugin = plugin;
-                if (typedPlugin.init) {
-                    const result = typedPlugin.init(ctx);
-                    if ('object' == typeof result) {
-                        if (result.options) options = (0, external_defu_namespaceObject.defu)(result.options, options);
-                        if (result.context) context = {
-                            ...context,
-                            ...result.context
-                        };
-                    }
-                }
-            }
-            context.options = options;
-            return (0, external_neverthrow_namespaceObject.ok)(context);
-        } catch (error) {
-            return fail(`Plugin initialization failed: ${error instanceof Error ? error.message : String(error)}`, {
-                code: error_codes_ERROR_CODES.PLUGIN_INITIALIZATION_FAILED,
-                meta: {
-                    error
-                }
-            });
-        }
-    }
-    function getInternalPlugins(_options) {
-        const plugins = [];
-        return plugins;
-    }
-    function defineRoute(pathOrConfig, handlerOrUndefined, options) {
-        if ('string' == typeof pathOrConfig && handlerOrUndefined) return {
-            path: pathOrConfig,
-            handler: handlerOrUndefined,
-            options
-        };
-        const config = pathOrConfig;
-        const handler = (0, external_h3_namespaceObject.defineEventHandler)(async (event)=>{
-            const logger = event.context.logger || createLogger();
-            logger.debug(`Handling request for ${config.method} ${config.path}`);
-            if (!event.context.logger) event.context.logger = logger;
-            const validated = {
-                body: void 0,
-                query: void 0,
-                params: void 0
-            };
-            try {
-                if (config.validations?.body) {
-                    const contentType = event.headers.get('content-type');
-                    const body = contentType?.includes('multipart/form-data') ? Object.fromEntries(await (0, external_h3_namespaceObject.readFormData)(event)) : await (0, external_h3_namespaceObject.readBody)(event);
-                    logger.debug('Validating request body', {
-                        body
-                    });
-                    const validateBody = validationPipeline(config.validations.body, (data)=>data);
-                    const result = await validateBody(body);
-                    result.match((data)=>{
-                        validated.body = data;
-                    }, (error)=>{
-                        logger.error('Validation error (body)', {
-                            error
-                        });
-                        throw new error_class_DoubleTieError('Body validation failed', {
-                            code: error_codes_ERROR_CODES.BAD_REQUEST,
-                            status: 422,
-                            cause: error instanceof Error ? error : void 0,
-                            meta: {
-                                validationErrors: error,
-                                requestPath: config.path,
-                                requestMethod: config.method
-                            }
-                        });
-                    });
-                }
-                if (config.validations?.query) {
-                    const query = getQuery(event);
-                    logger.debug('Validating query parameters', {
-                        query
-                    });
-                    const validateQuery = validationPipeline(config.validations.query, (data)=>data);
-                    const result = await validateQuery(query);
-                    result.match((data)=>{
-                        validated.query = data;
-                    }, (error)=>{
-                        logger.error('Query validation failed', {
-                            error
-                        });
-                        throw new error_class_DoubleTieError('Query validation failed', {
-                            code: error_codes_ERROR_CODES.BAD_REQUEST,
-                            status: 422,
-                            cause: error instanceof Error ? error : void 0,
-                            meta: {
-                                validationErrors: error,
-                                requestPath: config.path,
-                                requestMethod: config.method
-                            }
-                        });
-                    });
-                }
-                if (config.validations?.params) {
-                    const params = getRouterParams(event);
-                    logger.debug('Validating route parameters', {
-                        params
-                    });
-                    const validateParams = validationPipeline(config.validations.params, (data)=>data);
-                    const result = await validateParams(params);
-                    result.match((data)=>{
-                        validated.params = data;
-                    }, (error)=>{
-                        logger.error('Path parameters validation failed', {
-                            error
-                        });
-                        throw new error_class_DoubleTieError('Path parameters validation failed', {
-                            code: error_codes_ERROR_CODES.BAD_REQUEST,
-                            status: 422,
-                            cause: error instanceof Error ? error : void 0,
-                            meta: {
-                                validationErrors: error,
-                                requestPath: config.path,
-                                requestMethod: config.method
-                            }
-                        });
-                    });
-                }
-                const eventWithContext = event;
-                eventWithContext.context = {
-                    ...event.context,
-                    validated
-                };
-                logger.debug(`Executing handler for ${config.method} ${config.path}`);
-                const response = await config.handler(eventWithContext);
-                logger.debug(`Handler execution complete for ${config.method} ${config.path}, response type: ${typeof response}`);
-                if (null == response) {
-                    logger.warn(`Handler for ${config.method} ${config.path} returned ${null === response ? 'null' : 'undefined'}`);
-                    return {};
-                }
-                if ('boolean' == typeof response || 'number' == typeof response || 'string' == typeof response) {
-                    logger.warn(`Handler for ${config.method} ${config.path} returned primitive ${typeof response}, wrapping in object`);
-                    return {
-                        value: response
-                    };
-                }
-                return response;
-            } catch (error) {
-                if (error instanceof error_class_DoubleTieError) throw error;
-                logger.error('Validation failed', {
-                    error
-                });
-                let validationErrors = 'Unknown validation error';
-                let statusCode = 422;
-                if (error instanceof Error) {
-                    validationErrors = error.message;
-                    if ('ZodError' === error.name && 'format' in error && 'function' == typeof error.format) try {
-                        validationErrors = error.format();
-                        statusCode = 422;
-                    } catch  {
-                        validationErrors = `Validation error: ${error.message}`;
-                    }
-                }
-                logger.error('Validation failed', {
-                    error,
-                    validationErrors
-                });
-                throw new error_class_DoubleTieError('Validation failed', {
-                    code: error_codes_ERROR_CODES.BAD_REQUEST,
-                    status: statusCode,
-                    cause: error instanceof Error ? error : void 0,
-                    meta: {
-                        validationErrors,
-                        requestPath: config.path,
-                        requestMethod: config.method
-                    }
-                });
-            }
-        });
-        return {
-            path: config.path,
-            method: config.method,
-            handler,
-            responseType: {}
-        };
-    }
-    function getQuery(event) {
-        return (0, external_h3_namespaceObject.getQuery)(event);
-    }
-    function getRouterParams(event) {
-        return (0, external_h3_namespaceObject.getRouterParams)(event) || {};
-    }
-    const baseConsentSchema = external_zod_namespaceObject.z.object({
-        subjectId: external_zod_namespaceObject.z.string().optional(),
-        externalSubjectId: external_zod_namespaceObject.z.string().optional(),
-        domain: external_zod_namespaceObject.z.string(),
-        type: PolicyTypeSchema,
-        metadata: external_zod_namespaceObject.z.record(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.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.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.boolean()).optional()
-    });
-    const SetConsentRequestBody = external_zod_namespaceObject.z.discriminatedUnion('type', [
-        cookieBannerSchema,
-        policyBasedSchema,
-        otherConsentSchema
-    ]);
-    const setConsent = defineRoute({
-        path: '/consent/set',
-        method: 'post',
-        validations: {
-            body: SetConsentRequestBody
-        },
-        handler: async (event)=>{
-            const logger = event.context.logger || createLogger();
-            logger.info('Handling set-consent request');
-            const { body } = event.context.validated;
-            const { registry, adapter } = event.context;
-            const { type, subjectId, externalSubjectId, domain, metadata } = body;
-            logger.debug('Request parameters', {
-                type,
-                subjectId,
-                externalSubjectId,
-                domain
-            });
-            try {
-                const subject = await registry.findOrCreateSubject({
-                    subjectId,
-                    externalSubjectId,
-                    ipAddress: event.context.ipAddress || 'unknown'
-                });
-                if (!subject) {
-                    const errMsg = 'Subject not found or could not be created';
-                    logger.error(errMsg, {
-                        subjectId,
-                        externalSubjectId
-                    });
-                    throw new error_class_DoubleTieError(errMsg, {
-                        code: error_codes_ERROR_CODES.BAD_REQUEST,
-                        status: 400,
-                        meta: {
-                            subjectId,
-                            externalSubjectId
-                        }
-                    });
-                }
-                logger.debug('Subject found/created', {
-                    subjectId: subject.id
-                });
-                const domainRecord = await registry.findOrCreateDomain(domain);
-                const now = new Date();
-                let policyId;
-                let purposeIds = [];
-                if ('policyId' in body) {
-                    const { policyId: pid } = body;
-                    policyId = pid;
-                    if (!policyId) throw new error_class_DoubleTieError('Policy ID is required', {
-                        code: error_codes_ERROR_CODES.BAD_REQUEST,
-                        status: 400,
-                        meta: {
-                            type
-                        }
-                    });
-                    const policy = await registry.findConsentPolicyById(policyId);
-                    if (!policy) throw new error_class_DoubleTieError('Policy not found', {
-                        code: error_codes_ERROR_CODES.NOT_FOUND,
-                        status: 404,
-                        meta: {
-                            policyId
-                        }
-                    });
-                    if (!policy.isActive) throw new error_class_DoubleTieError('Policy is not active', {
-                        code: error_codes_ERROR_CODES.CONFLICT,
-                        status: 409,
-                        meta: {
-                            policyId
-                        }
-                    });
-                } else {
-                    const policy = await registry.findOrCreatePolicy(type);
-                    if (!policy) throw new error_class_DoubleTieError('Failed to create or find policy', {
-                        code: error_codes_ERROR_CODES.INTERNAL_SERVER_ERROR,
-                        status: 500,
-                        meta: {
-                            type
-                        }
-                    });
-                    policyId = policy.id;
-                }
-                if ('preferences' in body && body.preferences) purposeIds = await Promise.all(Object.entries(body.preferences).filter(([_, isConsented])=>isConsented).map(async ([purposeCode])=>{
-                    let existingPurpose = await registry.findConsentPurposeByCode(purposeCode);
-                    if (!existingPurpose) existingPurpose = await registry.createConsentPurpose({
-                        code: purposeCode,
-                        name: purposeCode,
-                        description: `Auto-created consentPurpose for ${purposeCode}`,
-                        isActive: true,
-                        isEssential: false,
-                        dataCategory: 'functional',
-                        legalBasis: 'consent',
-                        createdAt: now,
-                        updatedAt: now
-                    });
-                    return existingPurpose.id;
-                }));
-                const result = await adapter.transaction({
-                    callback: async (tx)=>{
-                        const consentRecord = await tx.create({
-                            model: 'consent',
-                            data: {
-                                subjectId: subject.id,
-                                domainId: domainRecord.id,
-                                policyId,
-                                purposeIds,
-                                status: 'active',
-                                isActive: true,
-                                givenAt: now,
-                                ipAddress: event.context.ipAddress || 'unknown',
-                                agent: event.context.userAgent || 'unknown',
-                                history: []
-                            }
-                        });
-                        const record = await tx.create({
-                            model: 'consentRecord',
-                            data: {
-                                subjectId: subject.id,
-                                consentId: consentRecord.id,
-                                actionType: 'consent_given',
-                                details: metadata,
-                                createdAt: now
-                            }
-                        });
-                        await tx.create({
-                            model: 'auditLog',
-                            data: {
-                                subjectId: subject.id,
-                                entityType: 'consent',
-                                entityId: consentRecord.id,
-                                actionType: 'consent_given',
-                                details: {
-                                    consentId: consentRecord.id,
-                                    type
-                                },
-                                timestamp: now,
-                                ipAddress: event.context.ipAddress || 'unknown',
-                                agent: event.context.userAgent || 'unknown'
-                            }
-                        });
-                        return {
-                            consent: consentRecord,
-                            record
-                        };
-                    }
-                });
-                if (!result || !result.consent || !result.record) throw new error_class_DoubleTieError('Failed to create consent record', {
-                    code: error_codes_ERROR_CODES.INTERNAL_SERVER_ERROR,
-                    status: 500,
-                    meta: {
-                        subjectId: subject.id,
-                        domain
-                    }
-                });
-                const response = {
-                    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.toISOString()
-                };
-                logger.info('Set-consent successful', {
-                    consentId: response.id
-                });
-                return response;
-            } catch (error) {
-                logger.error('Error in set-consent handler', {
-                    error: error instanceof Error ? error.message : String(error),
-                    errorType: error instanceof Error ? error.constructor.name : typeof error
-                });
-                throw error;
-            }
-        }
-    });
-    const show_consent_banner_showConsentBanner = defineRoute({
-        path: '/show-consent-banner',
-        method: 'get',
-        handler: async (event)=>{
-            const countryCode = event.headers.get('cf-ipcountry') || event.headers.get('x-vercel-ip-country') || event.headers.get('x-amz-cf-ipcountry') || event.headers.get('x-country-code');
-            const regionCode = event.headers.get('x-vercel-ip-country-region') || event.headers.get('x-region-code');
-            const { showConsentBanner, jurisdictionCode, message } = checkJurisdiction(countryCode ?? null);
-            return {
-                showConsentBanner,
-                jurisdiction: {
-                    code: jurisdictionCode,
-                    message
-                },
-                location: {
-                    countryCode,
-                    regionCode
-                }
-            };
-        }
-    });
-    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 = false;
-        let jurisdictionCode = 'NONE';
-        let message = 'No specific requirements';
-        if (countryCode) {
-            if (jurisdictions.EU.has(countryCode) || jurisdictions.EEA.has(countryCode) || jurisdictions.UK.has(countryCode)) {
-                showConsentBanner = true;
-                jurisdictionCode = 'GDPR';
-                message = 'GDPR or equivalent regulations require a cookie banner.';
-            } else if (jurisdictions.CH.has(countryCode)) {
-                showConsentBanner = true;
-                jurisdictionCode = 'CH';
-                message = 'Switzerland requires similar data protection measures.';
-            } else if (jurisdictions.BR.has(countryCode)) {
-                showConsentBanner = true;
-                jurisdictionCode = 'BR';
-                message = "Brazil's LGPD requires consent for cookies.";
-            } else if (jurisdictions.CA.has(countryCode)) {
-                showConsentBanner = true;
-                jurisdictionCode = 'PIPEDA';
-                message = 'PIPEDA requires consent for data collection.';
-            } else if (jurisdictions.AU.has(countryCode)) {
-                showConsentBanner = true;
-                jurisdictionCode = 'AU';
-                message = "Australia's Privacy Act mandates transparency about data collection.";
-            } else if (jurisdictions.JP.has(countryCode)) {
-                showConsentBanner = true;
-                jurisdictionCode = 'APPI';
-                message = "Japan's APPI requires consent for data collection.";
-            } else if (jurisdictions.KR.has(countryCode)) {
-                showConsentBanner = true;
-                jurisdictionCode = 'PIPA';
-                message = "South Korea's PIPA requires consent for data collection.";
-            }
-        }
-        return {
-            showConsentBanner,
-            jurisdictionCode,
-            message
-        };
-    }
-    var package_namespaceObject = {
-        i8: "1.0.0"
-    };
-    const status_status = defineRoute({
-        path: '/status',
-        method: 'get',
-        handler: async (event)=>{
-            const response = {
-                status: 'ok',
-                version: package_namespaceObject.i8,
-                timestamp: new Date().toISOString(),
-                storage: {
-                    type: event.context.adapter?.id ?? 'Unavailable',
-                    available: !!event.context.adapter
-                }
-            };
-            return response;
-        }
-    });
-    const VerifyConsentRequestBody = external_zod_namespaceObject.z.object({
-        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 verifyConsent = defineRoute({
-        path: '/consent/verify',
-        method: 'post',
-        validations: {
-            body: VerifyConsentRequestBody
-        },
-        handler: async (event)=>{
-            const { body } = event.context.validated;
-            const { type, subjectId, externalSubjectId, domain, policyId, preferences } = body;
-            const { registry } = event.context;
-            const subject = await registry.findOrCreateSubject({
-                subjectId,
-                externalSubjectId,
-                ipAddress: event.context.ipAddress || 'unknown'
-            });
-            if (!subject) return {
-                isValid: false,
-                reasons: [
-                    'Subject not found'
-                ]
-            };
-            const domainRecord = await registry.findDomain(domain);
-            if (!domainRecord) return {
-                isValid: false,
-                reasons: [
-                    'Domain not found'
-                ]
-            };
-            if ('cookie_banner' === type && preferences?.length === 0) return {
-                isValid: false,
-                reasons: [
-                    'Preferences are required'
-                ]
-            };
-            const purposePromises = preferences?.map((purpose)=>registry.findConsentPurposeByCode(purpose));
-            const rawPurposes = await Promise.all(purposePromises ?? []);
-            const purposeIds = rawPurposes.filter((purpose)=>null !== purpose).map((purpose)=>purpose.id);
-            if (purposeIds.length !== (preferences?.length ?? 0)) return {
-                isValid: false,
-                reasons: [
-                    'Could not find all purposes'
-                ]
-            };
-            if (policyId) {
-                const policy = await registry.findConsentPolicyById(policyId);
-                if (!policy || policy.type !== type) return {
-                    isValid: false,
-                    reasons: [
-                        'Policy not found'
-                    ]
-                };
-                return await policyConsentGiven({
-                    policyId: policy.id,
-                    subjectId: subject.id,
-                    domainId: domainRecord.id,
-                    purposeIds,
-                    type,
-                    event
-                });
-            }
-            const latestPolicy = await registry.findOrCreatePolicy(type);
-            if (!latestPolicy) return {
-                isValid: false,
-                reasons: [
-                    'Failed to find or create latest policy'
-                ]
-            };
-            return await policyConsentGiven({
-                policyId: latestPolicy.id,
-                subjectId: subject.id,
-                domainId: domainRecord.id,
-                purposeIds,
-                type,
-                event
-            });
-        }
-    });
-    async function policyConsentGiven({ policyId, subjectId, domainId, purposeIds, type, event }) {
-        const { registry, adapter } = event.context;
-        const rawConsents = await adapter.findMany({
-            model: 'consent',
-            where: [
-                {
-                    field: 'subjectId',
-                    value: subjectId
-                },
-                {
-                    field: 'policyId',
-                    value: policyId
-                },
-                {
-                    field: 'domainId',
-                    value: domainId
-                }
-            ],
-            sortBy: {
-                field: 'givenAt',
-                direction: 'desc'
-            }
-        });
-        const consents = rawConsents.map((consent)=>validateEntityOutput('consent', consent, {}));
-        const filteredConsents = consents.filter((consent)=>{
-            if (!purposeIds) return true;
-            return purposeIds.every((id)=>consent.purposeIds.some((purposeId)=>purposeId === id));
-        });
-        await registry.createAuditLog({
-            subjectId: subjectId,
-            entityType: 'consent_policy',
-            entityId: policyId,
-            actionType: 'verify_consent',
-            metadata: {
-                type,
-                policyId,
-                purposeIds,
-                success: 0 !== filteredConsents.length,
-                consentId: filteredConsents[0]?.id
-            }
-        });
-        if (0 === consents.length) return {
-            isValid: false,
-            reasons: [
-                'No consent found for the given policy'
-            ]
-        };
-        return {
-            isValid: true,
-            consent: filteredConsents[0]
-        };
-    }
-    const routes = [
-        status_status,
-        show_consent_banner_showConsentBanner,
-        setConsent,
-        verifyConsent
-    ];
-    const API_ROUTER_TRACER_NAME = '@doubletie/api-router';
-    const api_router_telemetry_getTracer = (options)=>{
-        if (options?.telemetry?.tracer) return options.telemetry.tracer;
-        return api_namespaceObject.trace.getTracer(API_ROUTER_TRACER_NAME);
-    };
-    const createRequestSpan = (method, path, options)=>{
-        if (options?.telemetry?.disabled) return null;
-        const tracer = api_router_telemetry_getTracer(options);
-        const span = tracer.startSpan(`${method} ${path}`, {
-            attributes: {
-                'http.method': method,
-                'http.path': path,
-                ...options?.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: api_namespaceObject.SpanStatusCode.OK
-            });
-            return result;
-        } catch (error) {
-            handleSpanError(span, error);
-            throw error;
-        } finally{
-            span.end();
-        }
-    };
-    const handleSpanError = (span, error)=>{
-        span.setStatus({
-            code: api_namespaceObject.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);
-        }
-    };
-    const STRIP_REGEX = /^(https?:\/\/)|(wss?:\/\/)|(\/+$)|:\d+/g;
-    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('*.')) {
-                    const wildcardDomain = strippedDomain.slice(2);
-                    const parts = originHostname.split('.');
-                    const isValid = parts.length > 2 && originHostname.endsWith(wildcardDomain);
-                    logger?.debug(`Wildcard match result: ${isValid} ${originHostname} ends with ${wildcardDomain} ${parts.length > 2} ${originHostname.endsWith(wildcardDomain)}`);
-                    return isValid;
-                }
-                const isMatch = originHostname === strippedDomain;
-                logger?.debug(`Exact match result: ${isMatch} ${originHostname} === ${strippedDomain}`);
-                return isMatch;
-            });
-        } catch (error) {
-            logger?.error('Error validating origin:', error);
-            return false;
-        }
-    }
-    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 getIp(req, options) {
-        const advanced = options.advanced || {};
-        if (advanced?.ipAddress?.disableIpTracking) return null;
-        const testIP = '127.0.0.1';
-        if (isTest) return testIP;
-        const ipHeaders = advanced?.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 null;
-    }
-    function createApiHandler({ options, context }) {
-        const { logger } = context;
-        logger.info('Creating API Handler');
-        const app = (0, external_h3_namespaceObject.createApp)({
-            onRequest (event) {
-                event.context.ipAddress = getIp(event.headers, options);
-                event.context.userAgent = event.node.req.headers['user-agent'] || null;
-                event.context.registry = context.registry;
-                event.context.adapter = context.adapter;
-                event.context.trustedOrigins = context.trustedOrigins;
-                event.context.logger = logger;
-                logger.debug(`Request received: ${event.method} ${event.path}`);
-            },
-            onError (error, event) {
-                if (event.context._onError && 'function' == typeof event.context._onError) return event.context._onError(error);
-                logger.error(`Unhandled API error in ${event.method} ${event.path}`, {
-                    error: error instanceof Error ? error.message : String(error),
-                    errorType: error instanceof Error ? error.constructor.name : typeof error
-                });
-            }
-        });
-        app.use(createH3ErrorHandler());
-        logger.debug('Added error handler middleware');
-        app.use((0, external_h3_namespaceObject.eventHandler)((event)=>{
-            if ((0, external_h3_namespaceObject.handleCors)(event, {
-                origin: (originStr)=>isOriginTrusted(originStr, event.context.trustedOrigins, logger),
-                methods: [
-                    'GET',
-                    'POST',
-                    'PUT',
-                    'DELETE',
-                    'PATCH',
-                    'OPTIONS'
-                ],
-                allowHeaders: [
-                    'Content-Type',
-                    'Authorization'
-                ],
-                credentials: true,
-                maxAge: '600'
-            })) return void logger.debug('CORS preflight response sent');
-        }));
-        const router = (0, external_h3_namespaceObject.createRouter)();
-        app.use(router);
-        logger.debug('Router initialized and registered with app');
-        for (const route of routes){
-            logger.debug(`Registering route: ${route.method} ${route.path}`);
-            router[route.method](route.path, withH3ErrorHandling((0, external_h3_namespaceObject.eventHandler)(async (event)=>{
-                logger.debug(`Handling request: ${route.method} ${route.path}`);
-                try {
-                    logger.debug(`Executing handler for ${route.path}`);
-                    const result = await withRequestSpan(event.method.toUpperCase(), route.path, ()=>route.handler(event), options);
-                    logger.debug(`Handler completed for ${route.path}`);
-                    if ('object' == typeof result && null !== result && 'pipe' in result && 'function' == typeof result.pipe) {
-                        logger.debug(`Sending stream response for ${route.path}`);
-                        return (0, external_h3_namespaceObject.sendStream)(event, result);
-                    }
-                    event.node.res.setHeader('Content-Type', 'application/json');
-                    return result;
-                } catch (error) {
-                    logger.error(`Error in route handler for ${route.path}`, {
-                        error: error instanceof Error ? error.message : String(error),
-                        errorType: error instanceof Error ? error.constructor.name : typeof error
-                    });
-                    throw error;
-                }
-            })));
-        }
-        const handler = (0, external_h3_namespaceObject.toWebHandler)(app);
-        logger.info('API handler created successfully');
-        return {
-            handler
-        };
-    }
-    const c15tInstance = (options)=>{
-        const contextPromise = init(options);
-        let webHandler = null;
-        const getHandler = async (ctx)=>{
-            if (!webHandler) {
-                const { handler } = createApiHandler({
-                    options: ctx.options,
-                    context: {
-                        adapter: ctx.adapter,
-                        registry: ctx.registry,
-                        trustedOrigins: ctx.trustedOrigins,
-                        logger: ctx.logger
-                    }
-                });
-                webHandler = handler;
-            }
-            return webHandler;
-        };
-        const handler = async (request)=>{
-            try {
-                const contextResult = await contextPromise;
-                return contextResult.match(async (ctx)=>{
-                    try {
-                        const handler = await getHandler(ctx);
-                        const response = await handler(request);
-                        return (0, external_neverthrow_namespaceObject.okAsync)(response);
-                    } catch (error) {
-                        return failAsync('Request handling failed', {
-                            code: error_codes_ERROR_CODES.REQUEST_HANDLER_ERROR,
-                            cause: error instanceof Error ? error : void 0
-                        });
-                    }
-                }, (error)=>failAsync(`Context initialization failed: ${error.message}`, {
-                        code: error_codes_ERROR_CODES.INITIALIZATION_FAILED,
-                        cause: error
-                    }));
-            } catch (error) {
-                return failAsync(`Unexpected error: ${error instanceof Error ? error.message : String(error)}`, {
-                    code: error_codes_ERROR_CODES.UNKNOWN_ERROR,
-                    cause: error instanceof Error ? error : void 0
-                });
-            }
-        };
-        return {
-            handler,
-            getApi: async ()=>{
-                const contextResult = await contextPromise;
-                return contextResult.match(()=>(0, external_neverthrow_namespaceObject.okAsync)(routes), (error)=>failAsync(`API retrieval failed: ${error.message}`, {
-                        code: error_codes_ERROR_CODES.API_RETRIEVAL_ERROR,
-                        cause: error
-                    }));
-            },
-            options,
-            $context: contextPromise
-        };
-    };
-})();
-exports.Types = __webpack_exports__.Types;
-exports.c15tInstance = __webpack_exports__.c15tInstance;
-for(var __webpack_i__ in __webpack_exports__)if (-1 === [
-    "Types",
-    "c15tInstance"
-].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
-Object.defineProperty(exports, '__esModule', {
-    value: true
-});