@c15t/backend 1.0.5 → 1.2.0-canary.0

package/dist/pkgs/data-model/schema/index.cjs

@@ -1,236 +1,5 @@
 "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;
-}
+var __webpack_require__ = {};
 (()=>{
     __webpack_require__.n = (module)=>{
         var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
@@ -262,1603 +31,1468 @@ function __webpack_require__(moduleId) {
     };
 })();
 var __webpack_exports__ = {};
-(()=>{
-    __webpack_require__.r(__webpack_exports__);
-    __webpack_require__.d(__webpack_exports__, {
-        getConsentPolicyTable: ()=>getConsentPolicyTable,
-        getDomainTable: ()=>getDomainTable,
-        getConsentTable: ()=>getConsentTable,
-        getAuditLogTable: ()=>getAuditLogTable,
-        purposeSchema: ()=>purposeSchema,
-        consentRegistry: ()=>consentRegistry,
-        domainSchema: ()=>domainSchema,
-        getSubjectTable: ()=>getSubjectTable,
-        policyRegistry: ()=>policyRegistry,
-        getPurposeTable: ()=>getPurposeTable,
-        auditLogRegistry: ()=>auditLogRegistry,
-        consentRecordSchema: ()=>consentRecordSchema,
-        subjectRegistry: ()=>subjectRegistry,
-        subjectSchema: ()=>subjectSchema,
-        getConsentRecordTable: ()=>getConsentRecordTable,
-        consentPolicySchema: ()=>consentPolicySchema,
-        consentSchema: ()=>consentSchema,
-        auditLogSchema: ()=>auditLogSchema,
-        PolicyTypeSchema: ()=>PolicyTypeSchema,
-        consentPurposeRegistry: ()=>consentPurposeRegistry,
-        domainRegistry: ()=>domainRegistry
-    });
-    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);
-    external_base_x_default()('123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz');
-    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([
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    getConsentPolicyTable: ()=>getConsentPolicyTable,
+    getDomainTable: ()=>getDomainTable,
+    getConsentTable: ()=>getConsentTable,
+    getAuditLogTable: ()=>getAuditLogTable,
+    purposeSchema: ()=>purposeSchema,
+    consentRegistry: ()=>consentRegistry,
+    domainSchema: ()=>domainSchema,
+    getSubjectTable: ()=>getSubjectTable,
+    policyRegistry: ()=>policyRegistry,
+    getPurposeTable: ()=>getPurposeTable,
+    auditLogRegistry: ()=>auditLogRegistry,
+    consentRecordSchema: ()=>consentRecordSchema,
+    subjectRegistry: ()=>subjectRegistry,
+    subjectSchema: ()=>subjectSchema,
+    getConsentRecordTable: ()=>getConsentRecordTable,
+    consentPolicySchema: ()=>consentPolicySchema,
+    consentSchema: ()=>consentSchema,
+    auditLogSchema: ()=>auditLogSchema,
+    PolicyTypeSchema: ()=>PolicyTypeSchema,
+    consentPurposeRegistry: ()=>consentPurposeRegistry,
+    domainRegistry: ()=>domainRegistry
+});
+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);
+external_base_x_default()('123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz');
+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["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"]()
+            external_zod_namespaceObject.z.promise(external_zod_namespaceObject.z.any())
         ])).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
-    ]);
-    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:
+        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
+]);
+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;
-                }
-            } else await hookFn(currentData, context);
-        }
-        return currentData;
+                    }
+                default:
+                    break;
+            }
+        } else await hookFn(currentData, context);
     }
-    async function processAfterHooksForMany(records, model, hooks, context) {
-        if (!records.length) return;
-        for (const record of records)await processHooks(record, model, 'update', 'after', hooks, 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;
     }
-    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;
+    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;
     }
-    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({
+    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
         });
-        if (updated) await processHooks(updated, model, 'update', 'after', hooks, context);
-        return updated;
+        updated = processUpdateManyResult(adapterResult);
     }
-    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
+    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)
+    };
+}
+require("neverthrow");
+const server_namespaceObject = require("@orpc/server");
+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 tracer = api_namespaceObject.trace.getTracer('@doubletie/results');
+async function tracing_withSpan(name, fn, attributes = {}) {
+    return await 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)
             });
-            updated = processUpdateManyResult(adapterResult);
+            span.end();
+            throw error;
         }
-        if (updated && updated.length > 0) await processAfterHooksForMany(updated, model, hooks, context);
-        return updated;
+    });
+}
+class error_class_DoubleTieError extends server_namespaceObject.ORPCError {
+    category;
+    meta;
+    statusCode;
+    constructor(message, options = {
+        code: error_codes_ERROR_CODES.UNKNOWN_ERROR,
+        status: 500,
+        category: ERROR_CATEGORIES.UNEXPECTED,
+        cause: void 0,
+        meta: {}
+    }){
+        super(options.code ?? error_codes_ERROR_CODES.UNKNOWN_ERROR, {
+            message,
+            cause: options.cause,
+            data: options.meta ?? {}
+        });
+        this.name = 'DoubleTieError';
+        this.category = options.category ?? ERROR_CATEGORIES.UNEXPECTED;
+        this.meta = options.meta ?? {};
+        this.statusCode = options.status ?? 500;
+        tracing_withSpan('create_doubletie_error', async (span)=>{
+            span.setAttributes({
+                'error.name': this.constructor.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);
     }
-    function getWithHooks(adapter, ctx) {
+    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 {
-            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)
+            code: this.code,
+            message: validationErrorMessage || this.message,
+            status: this.statusCode,
+            defined: true,
+            data: {
+                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
+                } : {}
+            }
         };
     }
-    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;
+    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
             }
         });
     }
-    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
+    static createSubclass(name) {
+        const ErrorSubclass = class extends error_class_DoubleTieError {
+            constructor(message, options){
+                super(message, options);
+                Object.defineProperty(this, 'name', {
+                    value: name
                 });
-                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;
-        }
+        };
+        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;
     }
-    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'
+}
+const logger_namespaceObject = require("@doubletie/logger");
+const 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: 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 || {}
         },
-        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'
-        }
+        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 levelColors = {
-        info: colors.fg.blue,
-        success: colors.fg.green,
-        warn: colors.fg.yellow,
-        error: colors.fg.red,
-        debug: colors.fg.magenta
+}
+const PolicyTypeSchema = external_zod_namespaceObject.z["enum"]([
+    'cookie_banner',
+    'privacy_policy',
+    'dpa',
+    'terms_and_conditions',
+    'marketing_communications',
+    'age_verification',
+    'other'
+]);
+const 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: 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 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 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: 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 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 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: 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 telemetry_getTracer = (options)=>{
-        if (options?.telemetry?.tracer) return options.telemetry.tracer;
-        return api_namespaceObject.trace.getTracer(LOGGER_TRACER_NAME);
+}
+const 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: 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 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 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: 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 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 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: 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 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);
-            });
+}
+const 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 Object.fromEntries(levels.map((level)=>[
-                level,
-                (...[message, ...args])=>logFunc(level, message, args).catch((error)=>{
-                        console.error('Logger error:', error);
-                    })
-            ]));
+        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
     };
-    const logger_factory_logger = createLogger();
-    const 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: 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 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: 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 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: 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 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: 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 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: 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 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: 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 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: 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
-        };
+};
+function validateEntityOutput(tableName, data, options) {
+    const tables = 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 external_zod_namespaceObject.ZodError) logger_namespaceObject.logger.error(`[validateEntityOutput] Validation failed for table ${String(tableName)}`, {
+            table,
+            issues: error.issues
+        });
+        throw error;
     }
-    const 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
+}
+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
                 },
-                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 = 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
+                model: 'subject',
+                customFn: void 0,
+                context
             });
-            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'
+            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('Failed to create or find subject with external ID', {
-                        code: error_codes_ERROR_CODES.INTERNAL_SERVER_ERROR,
-                        status: 500,
+                    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: {
-                            error: error instanceof Error ? error.message : 'Unknown error'
+                            providedSubjectId: subjectId,
+                            providedExternalId: externalSubjectId
                         }
                     });
                 }
-                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'
+                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('Failed to create anonymous subject', {
-                        code: error_codes_ERROR_CODES.INTERNAL_SERVER_ERROR,
-                        status: 500,
+                    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: {
-                            error: error instanceof Error ? error.message : 'Unknown error'
+                            providedSubjectId: subjectId,
+                            providedExternalId: externalSubjectId,
+                            subjectByIdId: subjectById.id,
+                            subjectByExternalIdId: subjectByExternalId.id
                         }
                     });
                 }
-            },
-            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 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
                 });
-                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 (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
                 });
-                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 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'
                 });
-                return createdConsent;
-            },
-            updateConsent: async (consentId, data, context)=>{
-                const consent = await updateWithHooks({
-                    data: {
-                        ...data
-                    },
-                    where: [
-                        {
-                            field: 'id',
-                            value: consentId
-                        }
-                    ],
-                    model: 'consent',
-                    context
+                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'
+                    }
                 });
-                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
+            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'
                 });
-                if (!createdPolicy) throw new error_class_DoubleTieError('Failed to create consent policy - operation returned null', {
+                throw new error_class_DoubleTieError('Failed to create anonymous subject', {
                     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'
+                    status: 500,
+                    meta: {
+                        error: error instanceof Error ? error.message : 'Unknown error'
                     }
                 });
-                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
-                        });
+            }
+        },
+        findSubjectById: async (subjectId)=>{
+            const subject = await adapter.findOne({
+                model: 'subject',
+                where: [
+                    {
+                        field: 'id',
+                        value: subjectId
                     }
-                })
-        };
-        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 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'
                         }
-                    ]
-                });
-                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({
+                    });
+                    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',
-                    value: params.name
-                });
-                const domains = await adapter.findMany({
-                    model: 'domain',
-                    where: whereConditions,
-                    sortBy: {
+                    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',
-                        direction: 'asc'
+                        value: name
                     }
-                });
-                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;
-            }
-        };
-    }
-})();
+                ]
+            });
+            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;
+        }
+    };
+}
 exports.PolicyTypeSchema = __webpack_exports__.PolicyTypeSchema;
 exports.auditLogRegistry = __webpack_exports__.auditLogRegistry;
 exports.auditLogSchema = __webpack_exports__.auditLogSchema;