@c15t/backend 0.0.1-rc.10

package/dist/index.cjs

@@ -0,0 +1,4777 @@
+var __webpack_modules__ = {
+    "./src/client/index.ts": function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+        "use strict";
+        __webpack_require__.d(__webpack_exports__, {
+            D: ()=>createConsentClient,
+            G: ()=>c15tClient
+        });
+        class c15tClient {
+            baseURL;
+            headers;
+            customFetch;
+            constructor(options){
+                this.baseURL = options.baseURL.endsWith('/') ? options.baseURL.slice(0, -1) : options.baseURL;
+                this.headers = {
+                    'Content-Type': 'application/json',
+                    ...options.headers
+                };
+                this.customFetch = options.fetchOptions?.customFetchImpl;
+            }
+            async fetcher(path, options = {}) {
+                try {
+                    const url = new URL(path, this.baseURL);
+                    if (options.query) {
+                        for (const [key, value] of Object.entries(options.query))if (void 0 !== value) {
+                            if (Array.isArray(value)) for (const v of value)url.searchParams.append(key, String(v));
+                            else url.searchParams.append(key, String(value));
+                        }
+                    }
+                    const fetchOptions = {
+                        method: options.method || 'GET',
+                        headers: {
+                            ...this.headers,
+                            ...options.headers
+                        }
+                    };
+                    if (options.body && 'GET' !== fetchOptions.method) fetchOptions.body = JSON.stringify(options.body);
+                    const fetchImpl = this.customFetch || fetch;
+                    const response = await fetchImpl(url.toString(), fetchOptions);
+                    let data = null;
+                    let error = null;
+                    if (204 !== response.status) try {
+                        data = await response.json();
+                    } catch (err) {
+                        if (response.ok) data = null;
+                        else error = new Error(`Failed to parse response: ${err.message}`);
+                    }
+                    const context = {
+                        data,
+                        response,
+                        error: error ? {
+                            message: error.message,
+                            status: response.status
+                        } : null,
+                        ok: response.ok
+                    };
+                    if (response.ok) {
+                        if (options.onSuccess) await options.onSuccess(context);
+                    } else {
+                        if (options.onError) await options.onError(context);
+                        if (options.throw) {
+                            const error = new Error(`Request failed with status ${response.status}`);
+                            Object.assign(error, {
+                                status: response.status,
+                                data
+                            });
+                            throw error;
+                        }
+                    }
+                    return context;
+                } catch (error) {
+                    if (options.onError) {
+                        const errorObj = error;
+                        const context = {
+                            data: null,
+                            error: {
+                                message: errorObj.message || 'Request failed',
+                                status: error.status || 500,
+                                code: error.code
+                            },
+                            ok: false,
+                            response: null
+                        };
+                        await options.onError(context);
+                        if (options.throw) throw error;
+                        return context;
+                    }
+                    if (options.throw) throw error;
+                    return {
+                        data: null,
+                        error: {
+                            message: error.message || 'Request failed',
+                            status: error.status || 500,
+                            code: error.code
+                        },
+                        ok: false,
+                        response: null
+                    };
+                }
+            }
+            async listPurposes(options) {
+                return this.fetcher('/list-purposes', {
+                    method: 'GET',
+                    ...options
+                });
+            }
+            async $fetch(path, options) {
+                return this.fetcher(path, options);
+            }
+        }
+        function createConsentClient(options) {
+            return new c15tClient(options);
+        }
+    },
+    "./src/client/types.ts": function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+        "use strict";
+        __webpack_require__.r(__webpack_exports__);
+    },
+    "./src/core.ts": function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+        "use strict";
+        __webpack_require__.d(__webpack_exports__, {
+            w: ()=>c15tInstance
+        });
+        const external_better_call_namespaceObject = require("better-call");
+        var env = __webpack_require__("./src/utils/env.ts");
+        function getIp(req, options) {
+            if (options.advanced?.ipAddress?.disableIpTracking) return null;
+            const testIP = '127.0.0.1';
+            if (env.Y8) return testIP;
+            const ipHeaders = options.advanced?.ipAddress?.ipAddressHeaders;
+            const keys = ipHeaders || [
+                'x-client-ip',
+                'x-forwarded-for',
+                'cf-connecting-ip',
+                'fastly-client-ip',
+                'x-real-ip',
+                'x-cluster-client-ip',
+                'x-forwarded',
+                'forwarded-for',
+                'forwarded'
+            ];
+            const headers = req instanceof Request ? req.headers : req;
+            for (const key of keys){
+                const value = headers.get(key);
+                if (value) {
+                    const ip = value.split(',')[0]?.trim();
+                    if (ip) return ip;
+                }
+            }
+            return null;
+        }
+        var utils_logger = __webpack_require__("./src/utils/logger.ts");
+        var src_error = __webpack_require__("./src/error/index.ts");
+        var utils_url = __webpack_require__("./src/utils/url.ts");
+        function escapeRegExpChar(char) {
+            if ('-' === char || '^' === char || '$' === char || '+' === char || '.' === char || '(' === char || ')' === char || '|' === char || '[' === char || ']' === char || '{' === char || '}' === char || '*' === char || '?' === char || '\\' === char) return `\\${char}`;
+            return char;
+        }
+        function escapeRegExpString(str) {
+            let result = '';
+            for (const char of str)result += escapeRegExpChar(char);
+            return result;
+        }
+        function wildcard_transform(pattern, separator = true) {
+            if (Array.isArray(pattern)) {
+                const regExpPatterns = pattern.map((p)=>`^${wildcard_transform(p, separator)}$`);
+                return `(?:${regExpPatterns.join('|')})`;
+            }
+            let separatorSplitter = '';
+            let separatorMatcher = '';
+            let wildcard = './';
+            if (true === separator) {
+                separatorSplitter = '/';
+                separatorMatcher = '[/\\\\]';
+                wildcard = '[^/\\\\]';
+            } else if (separator) {
+                separatorSplitter = separator;
+                separatorMatcher = escapeRegExpString(separatorSplitter);
+                if (separatorMatcher.length > 1) {
+                    separatorMatcher = `(?:${separatorMatcher})`;
+                    wildcard = `((?!${separatorMatcher}).)`;
+                } else wildcard = `[^${separatorMatcher}]`;
+            }
+            const requiredSeparator = separator ? `${separatorMatcher}+?` : '';
+            const optionalSeparator = separator ? `${separatorMatcher}*?` : '';
+            const segments = separator ? pattern.split(separatorSplitter) : [
+                pattern
+            ];
+            let result = '';
+            for(let s = 0; s < segments.length; s++){
+                const segment = segments[s];
+                const nextSegment = segments[s + 1];
+                let currentSeparator = '';
+                if (!!segment || !(s > 0)) {
+                    if (separator) currentSeparator = s === segments.length - 1 ? optionalSeparator : '**' !== nextSegment ? requiredSeparator : '';
+                    if (separator && '**' === segment) {
+                        if (currentSeparator) {
+                            result += 0 === s ? '' : currentSeparator;
+                            result += `(?:${wildcard}*?${currentSeparator})*?`;
+                        }
+                        continue;
+                    }
+                    if ('string' == typeof segment) {
+                        for(let c = 0; c < segment.length; c++){
+                            const char = segment[c];
+                            if ('\\' === char) {
+                                if (c < segment.length - 1) {
+                                    const nextChar = segment[c + 1];
+                                    if (void 0 !== nextChar) {
+                                        result += escapeRegExpChar(nextChar);
+                                        c++;
+                                    }
+                                }
+                            } else if ('?' === char) result += wildcard;
+                            else if ('*' === char) result += `${wildcard}*?`;
+                            else if (char) result += escapeRegExpChar(char);
+                        }
+                        result += currentSeparator;
+                    }
+                }
+            }
+            return result;
+        }
+        function isMatch(regexp, sample) {
+            if ('string' != typeof sample) throw new TypeError(`Sample must be a string, but ${typeof sample} given`);
+            return regexp.test(sample);
+        }
+        function wildcard_wildcardMatch(pattern, options) {
+            if ('string' != typeof pattern && !Array.isArray(pattern)) throw new TypeError(`The first argument must be a single pattern string or an array of patterns, but ${typeof pattern} given`);
+            const opts = 'string' == typeof options || 'boolean' == typeof options ? {
+                separator: options
+            } : options;
+            if (opts && !(void 0 === options || 'object' == typeof options && null !== options && !Array.isArray(options))) throw new TypeError(`The second argument must be an options object or a string/boolean separator, but ${typeof options} given`);
+            const normalizedOptions = opts || {};
+            if ('\\' === normalizedOptions.separator) throw new Error('\\ is not a valid separator because it is used for escaping. Try setting the separator to `true` instead');
+            const regexpPattern = wildcard_transform(pattern, normalizedOptions.separator);
+            const regexp = new RegExp(`^${regexpPattern}$`, normalizedOptions.flags);
+            const fn = isMatch.bind(null, regexp);
+            fn.options = normalizedOptions;
+            fn.pattern = pattern;
+            fn.regexp = regexp;
+            return fn;
+        }
+        const optionsMiddleware = (0, external_better_call_namespaceObject.createMiddleware)(async ()=>({}));
+        const call_createAuthMiddleware = external_better_call_namespaceObject.createMiddleware.create({
+            use: [
+                optionsMiddleware,
+                (0, external_better_call_namespaceObject.createMiddleware)(async ()=>({}))
+            ]
+        });
+        const createAuthEndpoint = external_better_call_namespaceObject.createEndpoint.create({
+            use: [
+                optionsMiddleware
+            ]
+        });
+        const VALID_RELATIVE_URL_REGEX = /^\/(?!\/|\\|%2f|%5c)[\w\-./]*(?:\?[\w\-./=&%]*)?$/;
+        const originCheckMiddleware = call_createAuthMiddleware(async (ctx)=>{
+            if (ctx.request?.method !== 'POST' || !ctx.request) return;
+            const { body, query, context } = ctx;
+            const originHeader = ctx.headers?.get('origin') || ctx.headers?.get('referer') || '';
+            const callbackURL = body?.callbackURL || query?.callbackURL;
+            const redirectURL = body?.redirectTo;
+            const errorCallbackURL = body?.errorCallbackURL;
+            const newSubjectCallbackURL = body?.newSubjectCallbackURL;
+            const trustedOrigins = Array.isArray(context.options.trustedOrigins) ? context.trustedOrigins : [
+                ...context.trustedOrigins,
+                ...context.options.trustedOrigins?.(ctx.request) || []
+            ];
+            const usesCookies = ctx.headers?.has('cookie');
+            const matchesPattern = (url, pattern)=>{
+                if (url.startsWith('/')) return false;
+                if (pattern.includes('*')) return wildcard_wildcardMatch(pattern)((0, utils_url.XF)(url));
+                const protocol = (0, utils_url.Ev)(url);
+                return 'http:' !== protocol && 'https:' !== protocol && protocol ? url.startsWith(pattern) : pattern === (0, utils_url.P$)(url);
+            };
+            const validateURL = (url, label)=>{
+                if (!url) return;
+                const isTrustedOrigin = trustedOrigins.some((origin)=>matchesPattern(url, origin) || url?.startsWith('/') && 'origin' !== label && VALID_RELATIVE_URL_REGEX.test(url));
+                if (!isTrustedOrigin) {
+                    ctx.context.logger.error(`Invalid ${label}: ${url}`);
+                    ctx.context.logger.info(`If it's a valid URL, please add ${url} to trustedOrigins in your auth config\n`, `Current list of trustedOrigins: ${trustedOrigins}`);
+                    throw new src_error.kO('The URL provided is not from a trusted origin. Please ensure the URL is correctly configured in the trusted origins list.', {
+                        code: src_error.H8.FORBIDDEN,
+                        status: 403,
+                        data: {
+                            url,
+                            label,
+                            trustedOrigins
+                        }
+                    });
+                }
+            };
+            if (usesCookies && !ctx.context.options.advanced?.disableCSRFCheck) validateURL(originHeader, 'origin');
+            callbackURL && validateURL(callbackURL, 'callbackURL');
+            redirectURL && validateURL(redirectURL, 'redirectURL');
+            errorCallbackURL && validateURL(errorCallbackURL, 'errorCallbackURL');
+            newSubjectCallbackURL && validateURL(newSubjectCallbackURL, 'newSubjectCallbackURL');
+        });
+        function redactContext(context) {
+            if (!context || 'object' != typeof context) return {
+                type: typeof context
+            };
+            const typedContext = context;
+            return {
+                baseURL: typedContext.baseURL,
+                storageType: typedContext.storage?.constructor.name,
+                pluginsCount: Array.isArray(typedContext.plugins) ? typedContext.plugins.length : 0,
+                hasOptions: !!typedContext.options,
+                hasLogger: !!typedContext.logger,
+                hasPlugins: !!typedContext.plugins
+            };
+        }
+        function validatePlugins(plugins, initializedPlugins) {
+            if (!plugins?.length) return null;
+            const initializedNames = new Set(initializedPlugins?.map((p)=>p.id) ?? []);
+            const failedPlugins = plugins.filter((p)=>!initializedNames.has(p.id)).map((p)=>p.id);
+            return failedPlugins.length > 0 ? failedPlugins : null;
+        }
+        const validateContextMiddleware = call_createAuthMiddleware(async (ctx)=>{
+            const { context } = ctx;
+            if (!context || 'object' != typeof context) throw new src_error.kO('The context configuration is incomplete. Please ensure all required configuration options are provided and properly formatted.', {
+                code: src_error.H8.INVALID_CONFIGURATION,
+                status: 500,
+                data: redactContext(context)
+            });
+            const typedContext = context;
+            if (!typedContext.options) throw new src_error.kO('The context configuration is missing required options. Please ensure the options object is properly configured.', {
+                code: src_error.H8.INVALID_CONFIGURATION,
+                status: 500
+            });
+            if (typedContext.storage) {
+                const storage = typedContext.storage;
+                const requiredMethods = [
+                    'subjects',
+                    'records',
+                    'policies'
+                ];
+                const missingMethods = requiredMethods.filter((method)=>!(method in storage));
+                if (missingMethods.length > 0) typedContext.logger?.warn?.('Storage adapter missing methods', {
+                    missingMethods,
+                    storageType: storage.constructor.name
+                });
+            }
+            if (!typedContext.logger && 'production' === process.env.NODE_ENV) throw new src_error.kO('Logger is required in production environment. Please configure a logger for your application.', {
+                code: src_error.H8.INVALID_CONFIGURATION,
+                status: 500,
+                data: {
+                    environment: process.env.NODE_ENV
+                }
+            });
+            const failedPlugins = validatePlugins(typedContext.options.plugins, typedContext.plugins);
+            if (failedPlugins) throw new src_error.kO('Plugin initialization failed. Some plugins could not be initialized properly. Please check your plugin configuration.', {
+                code: src_error.H8.PLUGIN_INITIALIZATION_FAILED,
+                status: 500,
+                data: {
+                    failedPlugins
+                }
+            });
+            typedContext.logger?.debug?.('Context validation successful', {
+                baseURL: typedContext.baseURL,
+                storageType: typedContext.storage?.constructor.name,
+                pluginsCount: Array.isArray(typedContext.plugins) ? typedContext.plugins.length : 0
+            });
+            return {
+                context: typedContext
+            };
+        });
+        const external_zod_namespaceObject = require("zod");
+        const ConsentType = external_zod_namespaceObject.z["enum"]([
+            'cookie_banner',
+            'privacy_policy',
+            'dpa',
+            'terms_of_service',
+            'marketing_communications',
+            'age_verification',
+            'other'
+        ]);
+        const baseConsentSchema = external_zod_namespaceObject.z.object({
+            subjectId: external_zod_namespaceObject.z.string().optional(),
+            externalSubjectId: external_zod_namespaceObject.z.string().optional(),
+            domain: external_zod_namespaceObject.z.string(),
+            type: ConsentType,
+            metadata: external_zod_namespaceObject.z.record(external_zod_namespaceObject.z.unknown()).optional()
+        });
+        const cookieBannerSchema = baseConsentSchema.extend({
+            type: external_zod_namespaceObject.z.literal('cookie_banner'),
+            preferences: external_zod_namespaceObject.z.record(external_zod_namespaceObject.z.boolean())
+        });
+        const policyBasedSchema = baseConsentSchema.extend({
+            type: external_zod_namespaceObject.z["enum"]([
+                'privacy_policy',
+                'dpa',
+                'terms_of_service'
+            ]),
+            policyId: external_zod_namespaceObject.z.string().optional(),
+            preferences: external_zod_namespaceObject.z.record(external_zod_namespaceObject.z.boolean()).optional()
+        });
+        const otherConsentSchema = baseConsentSchema.extend({
+            type: external_zod_namespaceObject.z["enum"]([
+                'marketing_communications',
+                'age_verification',
+                'other'
+            ]),
+            preferences: external_zod_namespaceObject.z.record(external_zod_namespaceObject.z.boolean()).optional()
+        });
+        const setConsentSchema = external_zod_namespaceObject.z.discriminatedUnion('type', [
+            cookieBannerSchema,
+            policyBasedSchema,
+            otherConsentSchema
+        ]);
+        const setConsent = createAuthEndpoint('/consent/set', {
+            method: 'POST',
+            body: setConsentSchema
+        }, async (ctx)=>{
+            try {
+                const body = setConsentSchema.parse(ctx.body);
+                const { type, subjectId, externalSubjectId, domain, metadata } = body;
+                const { registry, adapter } = ctx.context;
+                const subject = await registry.findOrCreateSubject({
+                    subjectId,
+                    externalSubjectId,
+                    ipAddress: ctx.context.ipAddress || 'unknown'
+                });
+                if (!subject) throw new src_error.kO('A valid Subject ID is required to proceed with the consent operation. Please provide a Subject ID.', {
+                    code: src_error.H8.MISSING_REQUIRED_PARAMETER,
+                    status: 400
+                });
+                const domainRecord = await registry.findOrCreateDomain(domain);
+                const now = new Date();
+                let policyId;
+                let purposeIds = [];
+                if ('policyId' in body) {
+                    const { policyId: pid } = body;
+                    policyId = pid;
+                    if (!policyId) throw new src_error.kO('A valid Policy ID is required to proceed with the consent operation. Please provide a Policy ID.', {
+                        code: src_error.H8.MISSING_REQUIRED_PARAMETER,
+                        status: 400
+                    });
+                    const policy = await registry.findConsentPolicyById(policyId);
+                    if (!policy) throw new src_error.kO('The specified consent policy could not be found. Please verify the policy ID and try again.', {
+                        code: src_error.H8.NOT_FOUND,
+                        status: 404
+                    });
+                    if (!policy.isActive) throw new src_error.kO('The consent policy is no longer active and cannot be used. Please use an active policy version.', {
+                        code: src_error.H8.CONFLICT,
+                        status: 409
+                    });
+                } else {
+                    const policy = await registry.findOrCreatePolicy(type.replace('_', ' '));
+                    if (!policy) throw new src_error.kO('Failed to create or find the required policy. Please try again later or contact support if the issue persists.', {
+                        code: src_error.H8.FAILED_TO_CREATE_PURPOSE,
+                        status: 500
+                    });
+                    policyId = policy.id;
+                }
+                if ('preferences' in body && body.preferences) purposeIds = await Promise.all(Object.entries(body.preferences).filter(([_, isConsented])=>isConsented).map(async ([purposeCode])=>{
+                    let existingPurpose = await registry.findConsentPurposeByCode(purposeCode);
+                    if (!existingPurpose) existingPurpose = await registry.createConsentPurpose({
+                        code: purposeCode,
+                        name: purposeCode,
+                        description: `Auto-created consentPurpose for ${purposeCode}`,
+                        isActive: true,
+                        isEssential: false,
+                        dataCategory: 'functional',
+                        legalBasis: 'consent',
+                        createdAt: now,
+                        updatedAt: now
+                    });
+                    return existingPurpose.id;
+                }));
+                const result = await adapter.transaction({
+                    callback: async (tx)=>{
+                        const consentRecord = await tx.create({
+                            model: 'consent',
+                            data: {
+                                subjectId: subject.id,
+                                domainId: domainRecord.id,
+                                policyId,
+                                purposeIds,
+                                status: 'active',
+                                isActive: true,
+                                givenAt: now,
+                                history: []
+                            }
+                        });
+                        const record = await tx.create({
+                            model: 'consentRecord',
+                            data: {
+                                subjectId: subject.id,
+                                consentId: consentRecord.id,
+                                actionType: 'consent_given',
+                                details: metadata,
+                                createdAt: now
+                            }
+                        });
+                        await tx.create({
+                            model: 'auditLog',
+                            data: {
+                                subjectId: subject.id,
+                                entityType: 'consent',
+                                entityId: consentRecord.id,
+                                actionType: 'consent_given',
+                                details: {
+                                    consentId: consentRecord.id,
+                                    type
+                                },
+                                timestamp: now
+                            }
+                        });
+                        return {
+                            consent: consentRecord,
+                            record
+                        };
+                    }
+                });
+                if (!result || !result.consent || !result.record) throw new src_error.kO('Failed to create the consent record. Please try again later or contact support if the issue persists.', {
+                    code: src_error.H8.FAILED_TO_CREATE_CONSENT,
+                    status: 500
+                });
+                return {
+                    id: result.consent.id,
+                    subjectId: subject.id,
+                    externalSubjectId: subject.externalId ?? void 0,
+                    domainId: domainRecord.id,
+                    domain: domainRecord.name,
+                    type,
+                    status: result.consent.status,
+                    recordId: result.record.id,
+                    metadata,
+                    givenAt: result.consent.givenAt.toISOString()
+                };
+            } catch (error) {
+                const context = ctx.context;
+                context.logger?.error?.('Error setting consent:', error);
+                if (error instanceof src_error.kO) throw error;
+                if (error instanceof external_zod_namespaceObject.z.ZodError) throw new src_error.kO('The consent data provided is invalid. Please ensure all required fields are correctly filled and formatted.', {
+                    code: src_error.H8.BAD_REQUEST,
+                    status: 400,
+                    data: {
+                        details: error.errors
+                    }
+                });
+                throw new src_error.kO('Failed to set consent. Please try again later or contact support if the issue persists.', {
+                    code: src_error.H8.FAILED_TO_CREATE_CONSENT,
+                    status: 500,
+                    data: {
+                        error: error instanceof Error ? error.message : String(error)
+                    }
+                });
+            }
+        });
+        const status_status = createAuthEndpoint('/status', {
+            method: 'GET'
+        }, async (ctx)=>{
+            const response = {
+                status: 'ok',
+                version: '1.0.0',
+                timestamp: new Date().toISOString(),
+                storage: {
+                    type: ctx.context?.adapter?.id ?? 'Unavailable',
+                    available: !!ctx.context?.adapter
+                }
+            };
+            return response;
+        });
+        const show_consent_banner_showConsentBanner = createAuthEndpoint('/show-consent-banner', {
+            method: 'GET',
+            metadata: {
+                openapi: {
+                    responses: {
+                        200: {
+                            description: 'Cookie Banner Requirement',
+                            content: {
+                                'application/json': {
+                                    schema: {
+                                        type: 'object',
+                                        properties: {
+                                            showConsentBanner: {
+                                                type: 'boolean'
+                                            },
+                                            jurisdiction: {
+                                                type: 'object',
+                                                properties: {
+                                                    code: {
+                                                        type: 'string'
+                                                    },
+                                                    message: {
+                                                        type: 'string'
+                                                    }
+                                                }
+                                            },
+                                            location: {
+                                                type: 'object',
+                                                properties: {
+                                                    countryCode: {
+                                                        type: 'string'
+                                                    },
+                                                    regionCode: {
+                                                        type: 'string'
+                                                    }
+                                                }
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }, async (c)=>{
+            const countryCode = c.headers?.get('cf-ipcountry') || c.headers?.get('x-vercel-ip-country') || c.headers?.get('x-amz-cf-ipcountry') || c.headers?.get('x-country-code');
+            const regionCode = c.headers?.get('x-vercel-ip-country-region') || c.headers?.get('x-region-code');
+            const { showConsentBanner, jurisdictionCode, message } = checkJurisdiction(countryCode ?? null);
+            return {
+                showConsentBanner,
+                jurisdiction: {
+                    code: jurisdictionCode,
+                    message
+                },
+                location: {
+                    countryCode,
+                    regionCode
+                }
+            };
+        });
+        function checkJurisdiction(countryCode) {
+            const jurisdictions = {
+                EU: new Set([
+                    'AT',
+                    'BE',
+                    'BG',
+                    'HR',
+                    'CY',
+                    'CZ',
+                    'DK',
+                    'EE',
+                    'FI',
+                    'FR',
+                    'DE',
+                    'GR',
+                    'HU',
+                    'IE',
+                    'IT',
+                    'LV',
+                    'LT',
+                    'LU',
+                    'MT',
+                    'NL',
+                    'PL',
+                    'PT',
+                    'RO',
+                    'SK',
+                    'SI',
+                    'ES',
+                    'SE'
+                ]),
+                EEA: new Set([
+                    'IS',
+                    'NO',
+                    'LI'
+                ]),
+                UK: new Set([
+                    'GB'
+                ]),
+                CH: new Set([
+                    'CH'
+                ]),
+                BR: new Set([
+                    'BR'
+                ]),
+                CA: new Set([
+                    'CA'
+                ]),
+                AU: new Set([
+                    'AU'
+                ]),
+                JP: new Set([
+                    'JP'
+                ]),
+                KR: new Set([
+                    'KR'
+                ])
+            };
+            let showConsentBanner = false;
+            let jurisdictionCode = 'NONE';
+            let message = 'No specific requirements';
+            if (countryCode) {
+                if (jurisdictions.EU.has(countryCode) || jurisdictions.EEA.has(countryCode) || jurisdictions.UK.has(countryCode)) {
+                    showConsentBanner = true;
+                    jurisdictionCode = 'GDPR';
+                    message = 'GDPR or equivalent regulations require a cookie banner.';
+                } else if (jurisdictions.CH.has(countryCode)) {
+                    showConsentBanner = true;
+                    jurisdictionCode = 'CH';
+                    message = 'Switzerland requires similar data protection measures.';
+                } else if (jurisdictions.BR.has(countryCode)) {
+                    showConsentBanner = true;
+                    jurisdictionCode = 'BR';
+                    message = "Brazil's LGPD requires consent for cookies.";
+                } else if (jurisdictions.CA.has(countryCode)) {
+                    showConsentBanner = true;
+                    jurisdictionCode = 'PIPEDA';
+                    message = 'PIPEDA requires consent for data collection.';
+                } else if (jurisdictions.AU.has(countryCode)) {
+                    showConsentBanner = true;
+                    jurisdictionCode = 'AU';
+                    message = "Australia's Privacy Act mandates transparency about data collection.";
+                } else if (jurisdictions.JP.has(countryCode)) {
+                    showConsentBanner = true;
+                    jurisdictionCode = 'APPI';
+                    message = "Japan's APPI requires consent for data collection.";
+                } else if (jurisdictions.KR.has(countryCode)) {
+                    showConsentBanner = true;
+                    jurisdictionCode = 'PIPA';
+                    message = "South Korea's PIPA requires consent for data collection.";
+                }
+            }
+            return {
+                showConsentBanner,
+                jurisdictionCode,
+                message
+            };
+        }
+        var hide_metadata = __webpack_require__("./src/utils/hide-metadata.ts");
+        function sanitize(input) {
+            return input.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;').replace(/"/g, '&quot;').replace(/'/g, '&#39;');
+        }
+        const html = (errorCode = 'Unknown')=>`<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Authentication Error</title>
+    <style>
+        :root {
+            --bg-color: #f8f9fa;
+            --text-color: #212529;
+            --accent-color: #000000;
+            --error-color: #dc3545;
+            --border-color: #e9ecef;
+        }
+        body {
+            font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, 'Helvetica Neue', Arial, sans-serif;
+            background-color: var(--bg-color);
+            color: var(--text-color);
+            display: flex;
+            justify-content: center;
+            align-items: center;
+            height: 100vh;
+            margin: 0;
+            line-height: 1.5;
+        }
+        .error-container {
+            background-color: #ffffff;
+            border-radius: 12px;
+            box-shadow: 0 4px 6px rgba(0, 0, 0, 0.05);
+            padding: 2.5rem;
+            text-align: center;
+            max-width: 90%;
+            width: 400px;
+        }
+        h1 {
+            color: var(--error-color);
+            font-size: 1.75rem;
+            margin-bottom: 1rem;
+            font-weight: 600;
+        }
+        p {
+            margin-bottom: 1.5rem;
+            color: #495057;
+        }
+        .btn {
+            background-color: var(--accent-color);
+            color: #ffffff;
+            text-decoration: none;
+            padding: 0.75rem 1.5rem;
+            border-radius: 6px;
+            transition: all 0.3s ease;
+            display: inline-block;
+            font-weight: 500;
+            border: 2px solid var(--accent-color);
+        }
+        .btn:hover {
+            background-color: #131721;
+        }
+        .error-code {
+            font-size: 0.875rem;
+            color: #6c757d;
+            margin-top: 1.5rem;
+            padding-top: 1.5rem;
+            border-top: 1px solid var(--border-color);
+        }
+        .icon {
+            font-size: 3rem;
+            margin-bottom: 1rem;
+        }
+    </style>
+</head>
+<body>
+    <div class="error-container">
+        <div class="icon">⚠️</div>
+        <h1>C15T Error</h1>
+        <p>We encountered an issue while processing your request. Please try again or contact the application owner if the problem persists.</p>
+        <a href="/" id="returnLink" class="btn">Return to Application</a>
+        <div class="error-code">Error Code: <span id="errorCode">${sanitize(errorCode)}</span></div>
+    </div>
+</body>
+</html>`;
+        createAuthEndpoint('/error', {
+            method: 'GET',
+            metadata: {
+                ...hide_metadata.a,
+                openapi: {
+                    description: 'Displays an error page',
+                    responses: {
+                        400: {
+                            description: 'Error page displayed',
+                            content: {
+                                'text/html': {
+                                    schema: {
+                                        type: 'string'
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }, async (c)=>{
+            const query = new URL(c.request?.url || '').searchParams.get('error') || 'Unknown';
+            return new Response(html(query), {
+                status: 400,
+                headers: {
+                    'Content-Type': 'text/html'
+                }
+            });
+        });
+        const ok = createAuthEndpoint('/ok', {
+            method: 'GET',
+            metadata: {
+                ...hide_metadata.a,
+                openapi: {
+                    description: 'Check if the API is working',
+                    responses: {
+                        200: {
+                            description: 'Success',
+                            content: {
+                                'application/json': {
+                                    schema: {
+                                        type: 'object',
+                                        properties: {
+                                            ok: {
+                                                type: 'boolean'
+                                            },
+                                            version: {
+                                                type: 'string'
+                                            },
+                                            timestamp: {
+                                                type: 'string'
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }, async (ctx)=>ctx.json({
+                ok: true,
+                version: process.env.API_VERSION || '1.0.0',
+                timestamp: new Date().toISOString()
+            }));
+        const baseEndpoints = {
+            setConsent: setConsent,
+            showConsentBanner: show_consent_banner_showConsentBanner,
+            status: status_status
+        };
+        const external_defu_namespaceObject = require("defu");
+        var external_defu_default = /*#__PURE__*/ __webpack_require__.n(external_defu_namespaceObject);
+        function toEndpoints(endpoints, ctx) {
+            const api = {};
+            for (const [key, endpoint] of Object.entries(endpoints)){
+                api[key] = async (context)=>{
+                    const C15TContext = await ctx;
+                    let internalContext = {
+                        ...context,
+                        context: {
+                            ...C15TContext,
+                            returned: void 0,
+                            responseHeaders: void 0,
+                            session: null
+                        },
+                        path: endpoint.path,
+                        headers: context?.headers ? new Headers(context?.headers) : void 0
+                    };
+                    const { beforeHooks, afterHooks } = getHooks(C15TContext);
+                    const before = await runBeforeHooks(internalContext, beforeHooks);
+                    if ('context' in before && before.context && 'object' == typeof before.context) {
+                        const { headers, ...rest } = before.context;
+                        if (headers) headers.forEach((value, key)=>{
+                            internalContext.headers.set(key, value);
+                        });
+                        internalContext = external_defu_default()(rest, internalContext);
+                    } else if (before) return before;
+                    internalContext.asResponse = false;
+                    internalContext.returnHeaders = true;
+                    const result = await endpoint(internalContext).catch((e)=>{
+                        if (e instanceof external_better_call_namespaceObject.APIError) return {
+                            response: e,
+                            headers: e.headers ? new Headers(e.headers) : null
+                        };
+                        throw e;
+                    });
+                    internalContext.context.returned = result.response;
+                    internalContext.context.responseHeaders = result.headers;
+                    const after = await runAfterHooks(internalContext, afterHooks);
+                    if (after.response) result.response = after.response;
+                    if (result.response instanceof external_better_call_namespaceObject.APIError && !context?.asResponse) throw result.response;
+                    let response;
+                    response = context?.asResponse ? (0, external_better_call_namespaceObject.toResponse)(result.response, {
+                        headers: result.headers
+                    }) : context?.returnHeaders ? {
+                        headers: result.headers,
+                        response: result.response
+                    } : result.response;
+                    return response;
+                };
+                api[key].path = endpoint.path;
+                api[key].options = endpoint.options;
+            }
+            return api;
+        }
+        async function runBeforeHooks(context, hooks) {
+            let modifiedContext = {};
+            for (const hook of hooks)if (hook.matcher(context)) {
+                const result = await hook.handler({
+                    ...context,
+                    returnHeaders: false
+                });
+                if (result && 'object' == typeof result) {
+                    if ('context' in result && 'object' == typeof result.context) {
+                        const { headers, ...rest } = result.context;
+                        if (headers instanceof Headers) {
+                            if (modifiedContext.headers) headers.forEach((value, key)=>{
+                                modifiedContext.headers?.set(key, value);
+                            });
+                            else modifiedContext.headers = headers;
+                        }
+                        modifiedContext = external_defu_default()(rest, modifiedContext);
+                        continue;
+                    }
+                    return result;
+                }
+            }
+            return {
+                context: modifiedContext
+            };
+        }
+        async function runAfterHooks(context, hooks) {
+            for (const hook of hooks)if (hook.matcher(context)) {
+                const result = await hook.handler(context).catch((e)=>{
+                    if (e instanceof external_better_call_namespaceObject.APIError) return {
+                        response: e,
+                        headers: e.headers ? new Headers(e.headers) : null
+                    };
+                    throw e;
+                });
+                if (result.headers) result.headers.forEach((value, key)=>{
+                    if (context.context.responseHeaders) {
+                        if ('set-cookie' === key.toLowerCase()) context.context.responseHeaders.append(key, value);
+                        else context.context.responseHeaders.set(key, value);
+                    } else {
+                        context.context.responseHeaders = new Headers();
+                        context.context.responseHeaders.set(key, value);
+                    }
+                });
+                if (result.response) context.context.returned = result.response;
+            }
+            return {
+                response: context.context.returned,
+                headers: context.context.responseHeaders
+            };
+        }
+        function getHooks(C15TContext) {
+            const plugins = C15TContext.options.plugins || [];
+            const beforeHooks = [];
+            const afterHooks = [];
+            if (C15TContext.options.hooks?.before) beforeHooks.push({
+                matcher: ()=>true,
+                handler: C15TContext.options.hooks.before
+            });
+            if (C15TContext.options.hooks?.after) afterHooks.push({
+                matcher: ()=>true,
+                handler: C15TContext.options.hooks.after
+            });
+            const pluginBeforeHooks = plugins.map((plugin)=>{
+                if (plugin.hooks?.before) return plugin.hooks.before;
+            }).filter((plugin)=>void 0 !== plugin).flat();
+            const pluginAfterHooks = plugins.map((plugin)=>{
+                if (plugin.hooks?.after) return plugin.hooks.after;
+            }).filter((plugin)=>void 0 !== plugin).flat();
+            pluginBeforeHooks.length && beforeHooks.push(...pluginBeforeHooks);
+            pluginAfterHooks.length && afterHooks.push(...pluginAfterHooks);
+            return {
+                beforeHooks,
+                afterHooks
+            };
+        }
+        function getEndpoints(ctx, options) {
+            const pluginEndpoints = options.plugins?.reduce((acc, plugin)=>{
+                if (plugin.endpoints) Object.assign(acc, plugin.endpoints);
+                return acc;
+            }, {});
+            const middlewares = options.plugins?.map((plugin)=>plugin.middlewares?.map((m)=>{
+                    const middleware = async (context)=>m.middleware({
+                            ...context,
+                            context: {
+                                ...ctx,
+                                ...context.context
+                            }
+                        });
+                    middleware.options = m.middleware.options;
+                    return {
+                        path: m.path,
+                        middleware
+                    };
+                })).filter((plugin)=>void 0 !== plugin).flat() || [];
+            const endpoints = {
+                ...baseEndpoints,
+                ...pluginEndpoints,
+                ok: ok
+            };
+            const api = toEndpoints(endpoints, ctx);
+            return {
+                api: api,
+                middlewares
+            };
+        }
+        const router = (ctx, options)=>{
+            const { api, middlewares } = getEndpoints(ctx, options);
+            let basePath = '';
+            try {
+                if (ctx.baseURL) {
+                    const url = new URL(ctx.baseURL);
+                    basePath = url.pathname;
+                }
+            } catch  {
+                basePath = '/api/c15t';
+            }
+            if (!basePath || '/' === basePath) basePath = '/api/c15t';
+            const routerInstance = (0, external_better_call_namespaceObject.createRouter)(api, {
+                routerContext: ctx,
+                openapi: {
+                    disabled: false
+                },
+                basePath,
+                routerMiddleware: [
+                    {
+                        path: '/**',
+                        middleware: validateContextMiddleware
+                    },
+                    {
+                        path: '/**',
+                        middleware: originCheckMiddleware
+                    },
+                    ...middlewares
+                ],
+                async onRequest (req) {
+                    ctx.ipAddress = getIp(req, options);
+                    ctx.userAgent = req.headers.get('user-agent');
+                    for (const plugin of ctx.options.plugins || [])if (plugin.onRequest) {
+                        const response = await plugin.onRequest(req, ctx);
+                        if (response && 'response' in response) return response.response;
+                    }
+                    return req;
+                },
+                async onResponse (res) {
+                    for (const plugin of ctx.options.plugins || [])if (plugin.onResponse) {
+                        const response = await plugin.onResponse(res, ctx);
+                        if (response) return response.response;
+                    }
+                    return res;
+                },
+                onError (e) {
+                    if (e instanceof external_better_call_namespaceObject.APIError && 'FOUND' === e.status) return;
+                    if (options.onAPIError?.throw) throw e;
+                    if (options.onAPIError?.onError) {
+                        options.onAPIError.onError(e, ctx);
+                        return;
+                    }
+                    const optLogLevel = options.logger?.level;
+                    const log = 'error' === optLogLevel || 'warn' === optLogLevel || 'debug' === optLogLevel ? utils_logger.kg : void 0;
+                    if (options.logger?.disabled !== true) {
+                        if (e && 'object' == typeof e && 'message' in e && 'string' == typeof e.message && (e.message.includes('no column') || e.message.includes('column') || e.message.includes('relation') || e.message.includes('table') || e.message.includes('does not exist'))) {
+                            ctx.logger?.error(e.message);
+                            return;
+                        }
+                        if (e instanceof external_better_call_namespaceObject.APIError) {
+                            if ('INTERNAL_SERVER_ERROR' === e.status) ctx.logger.error(e.status, e);
+                            log?.error(e.message);
+                        } else ctx.logger?.error(e && 'object' == typeof e && 'name' in e ? e.name : '', e);
+                    }
+                }
+            });
+            return routerInstance;
+        };
+        async function processHooks(data, model, operation, phase, hooks, context) {
+            let currentData = {
+                ...data
+            };
+            for (const hookSet of hooks){
+                const modelHooks = hookSet[model];
+                if (!modelHooks) continue;
+                const operationHooks = modelHooks[operation];
+                if (!operationHooks) continue;
+                const hookFn = operationHooks[phase];
+                if (!!hookFn) {
+                    if ('before' === phase) {
+                        const result = await hookFn(currentData, context);
+                        if (result && 'object' == typeof result && 'kind' in result) switch(result.kind){
+                            case 'abort':
+                                return null;
+                            case 'transform':
+                                {
+                                    const transformData = result.data;
+                                    currentData = {
+                                        ...currentData,
+                                        ...transformData
+                                    };
+                                    break;
+                                }
+                            default:
+                                break;
+                        }
+                    } else await hookFn(currentData, context);
+                }
+            }
+            return currentData;
+        }
+        async function processAfterHooksForMany(records, model, hooks, context) {
+            if (!records.length) return;
+            for (const record of records)await processHooks(record, model, 'update', 'after', hooks, context);
+        }
+        async function createWithHook(adapter, ctx, props) {
+            const { data, model, customFn, context } = props;
+            const hooks = ctx.hooks || [];
+            const transformedData = await processHooks(data, model, 'create', 'before', hooks, context);
+            if (null === transformedData) return null;
+            let created = null;
+            if (customFn) {
+                created = await customFn.fn(transformedData);
+                if (!customFn.executeMainFn && created) return created;
+            }
+            if (!created) created = await adapter.create({
+                model: model,
+                data: transformedData
+            });
+            if (created) await processHooks(created, model, 'create', 'after', hooks, context);
+            return created;
+        }
+        async function update_hooks_updateWithHooks(adapter, ctx, props) {
+            const { data, where, model, customFn, context } = props;
+            const hooks = ctx.hooks || [];
+            const transformedData = await processHooks(data, model, 'update', 'before', hooks, context);
+            if (null === transformedData) return null;
+            let updated = null;
+            if (customFn) {
+                const result = await customFn.fn(transformedData);
+                updated = result;
+                if (!customFn.executeMainFn && updated) return updated;
+            }
+            if (!updated) updated = await adapter.update({
+                model: model,
+                update: transformedData,
+                where
+            });
+            if (updated) await processHooks(updated, model, 'update', 'after', hooks, context);
+            return updated;
+        }
+        async function executeCustomFunction(data, customFn) {
+            if (!customFn) return {
+                result: null,
+                shouldContinue: true
+            };
+            const result = await customFn.fn(data);
+            const shouldContinue = !result || !!customFn.executeMainFn;
+            return {
+                result,
+                shouldContinue
+            };
+        }
+        function processUpdateManyResult(result) {
+            if (Array.isArray(result)) return result;
+            if ('number' == typeof result && result > 0) return [];
+            return null;
+        }
+        async function updateManyWithHooks(adapter, ctx, props) {
+            const { data, where, model, customFn, context } = props;
+            const hooks = ctx.hooks || [];
+            const transformedData = await processHooks(data, model, 'update', 'before', hooks, context);
+            if (null === transformedData) return null;
+            const { result: customResult, shouldContinue } = await executeCustomFunction(transformedData, customFn);
+            if (customResult && !shouldContinue) return customResult;
+            let updated = customResult;
+            if (!updated) {
+                const adapterResult = await adapter.updateMany({
+                    model: model,
+                    update: transformedData,
+                    where
+                });
+                updated = processUpdateManyResult(adapterResult);
+            }
+            if (updated && updated.length > 0) await processAfterHooksForMany(updated, model, hooks, context);
+            return updated;
+        }
+        function getWithHooks(adapter, ctx) {
+            return {
+                createWithHooks: ({ data, model, customFn, context })=>createWithHook(adapter, ctx, {
+                        data,
+                        model,
+                        customFn,
+                        context
+                    }),
+                updateWithHooks: (props)=>update_hooks_updateWithHooks(adapter, ctx, props),
+                updateManyWithHooks: (props)=>updateManyWithHooks(adapter, ctx, props)
+            };
+        }
+        const definition_getConsentTables = (options)=>{
+            const pluginSchema = options.plugins?.reduce((acc, plugin)=>{
+                const schema = plugin.schema;
+                if (!schema) return acc;
+                for (const [key, value] of Object.entries(schema))acc[key] = {
+                    fields: {
+                        ...acc[key]?.fields,
+                        ...value.fields
+                    },
+                    entityName: value.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),
+                consentPurposeJunction: getPurposeJunctionTable(options, consentPurposeJunction?.fields),
+                consentRecord: getConsentRecordTable(options, record?.fields),
+                consentGeoLocation: getConsentGeoLocationTable(options, consentGeoLocation?.fields),
+                consentWithdrawal: getConsentWithdrawalTable(options, consentWithdrawal?.fields),
+                auditLog: getAuditLogTable(options, auditLog?.fields),
+                geoLocation: getGeoLocationTable(options, geoLocation?.fields),
+                ...pluginTables
+            };
+        };
+        function validateEntityOutput(tableName, data, options) {
+            const tables = definition_getConsentTables(options);
+            const table = tables[tableName];
+            if (!table) throw new Error(`Table ${tableName} not found`);
+            return table.schema.parse(data);
+        }
+        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('Failed to create consent audit log - operation returned null');
+                    return createdLog;
+                },
+                findAuditLogs: async (entityType, entityId, actionType, limit, offset)=>{
+                    const whereConditions = [];
+                    if (entityType) whereConditions.push({
+                        field: 'entityType',
+                        value: entityType
+                    });
+                    if (entityId) whereConditions.push({
+                        field: 'entityId',
+                        value: entityId
+                    });
+                    if (actionType) whereConditions.push({
+                        field: 'actionType',
+                        value: actionType
+                    });
+                    const logs = await adapter.findMany({
+                        model: 'auditLog',
+                        where: whereConditions,
+                        sortBy: {
+                            field: 'createdAt',
+                            direction: 'desc'
+                        },
+                        limit,
+                        offset
+                    });
+                    return logs.map((log)=>validateEntityOutput('auditLog', log, ctx.options));
+                },
+                findAuditLogById: async (auditLogId)=>{
+                    const log = await adapter.findOne({
+                        model: 'auditLog',
+                        where: [
+                            {
+                                field: 'id',
+                                value: auditLogId
+                            }
+                        ]
+                    });
+                    return log ? validateEntityOutput('auditLog', log, ctx.options) : null;
+                },
+                findAuditLogsByEntity: async (entityType, entityId, limit)=>{
+                    const logs = await adapter.findMany({
+                        model: 'auditLog',
+                        where: [
+                            {
+                                field: 'entityType',
+                                value: entityType
+                            },
+                            {
+                                field: 'entityId',
+                                value: entityId
+                            }
+                        ],
+                        sortBy: {
+                            field: 'createdAt',
+                            direction: 'desc'
+                        },
+                        limit
+                    });
+                    return logs.map((log)=>validateEntityOutput('auditLog', log, ctx.options));
+                },
+                countAuditLogs: async (entityType, entityId, actionType)=>{
+                    const whereConditions = [];
+                    if (entityType) whereConditions.push({
+                        field: 'entityType',
+                        value: entityType
+                    });
+                    if (entityId) whereConditions.push({
+                        field: 'entityId',
+                        value: entityId
+                    });
+                    if (actionType) whereConditions.push({
+                        field: 'actionType',
+                        value: actionType
+                    });
+                    return adapter.count({
+                        model: 'auditLog',
+                        where: whereConditions
+                    });
+                }
+            };
+        }
+        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())
+        });
+        var external_superjson_ = __webpack_require__("superjson");
+        var external_superjson_default = /*#__PURE__*/ __webpack_require__.n(external_superjson_);
+        const fieldConfigSchema = external_zod_namespaceObject.z.object({
+            required: external_zod_namespaceObject.z.boolean().default(true),
+            returned: external_zod_namespaceObject.z.boolean().default(true),
+            input: external_zod_namespaceObject.z.boolean().default(true),
+            defaultValue: external_zod_namespaceObject.z.union([
+                external_zod_namespaceObject.z.any(),
+                external_zod_namespaceObject.z["function"]().returns(external_zod_namespaceObject.z.any())
+            ]).optional(),
+            transform: external_zod_namespaceObject.z.object({
+                input: external_zod_namespaceObject.z["function"]().args(external_zod_namespaceObject.z.any()).returns(external_zod_namespaceObject.z.union([
+                    external_zod_namespaceObject.z.any(),
+                    external_zod_namespaceObject.z.promise(external_zod_namespaceObject.z.any())
+                ])).optional(),
+                output: external_zod_namespaceObject.z["function"]().args(external_zod_namespaceObject.z.any()).returns(external_zod_namespaceObject.z.union([
+                    external_zod_namespaceObject.z.any(),
+                    external_zod_namespaceObject.z.promise(external_zod_namespaceObject.z.any())
+                ])).optional()
+            }).optional(),
+            validator: external_zod_namespaceObject.z["function"]().args(external_zod_namespaceObject.z.any()).returns(external_zod_namespaceObject.z.union([
+                external_zod_namespaceObject.z.string(),
+                external_zod_namespaceObject.z["null"]()
+            ])).optional(),
+            unique: external_zod_namespaceObject.z.boolean().optional(),
+            indexed: external_zod_namespaceObject.z.boolean().optional(),
+            sortable: external_zod_namespaceObject.z.boolean().default(true),
+            fieldName: external_zod_namespaceObject.z.string().optional(),
+            bigint: external_zod_namespaceObject.z.boolean().default(false)
+        });
+        const stringFieldSchema = fieldConfigSchema.extend({
+            type: external_zod_namespaceObject.z.literal('string'),
+            minLength: external_zod_namespaceObject.z.number().optional(),
+            maxLength: external_zod_namespaceObject.z.number().optional(),
+            pattern: external_zod_namespaceObject.z.string().optional()
+        });
+        const numberFieldSchema = fieldConfigSchema.extend({
+            type: external_zod_namespaceObject.z.literal('number'),
+            min: external_zod_namespaceObject.z.number().optional(),
+            max: external_zod_namespaceObject.z.number().optional()
+        });
+        const booleanFieldSchema = fieldConfigSchema.extend({
+            type: external_zod_namespaceObject.z.literal('boolean')
+        });
+        const dateFieldSchema = fieldConfigSchema.extend({
+            type: external_zod_namespaceObject.z.literal('date'),
+            minDate: external_zod_namespaceObject.z.date().optional(),
+            maxDate: external_zod_namespaceObject.z.date().optional(),
+            dateOnly: external_zod_namespaceObject.z.boolean().default(false),
+            format: external_zod_namespaceObject.z.record(external_zod_namespaceObject.z.unknown()).optional()
+        });
+        const timezoneFieldSchema = fieldConfigSchema.extend({
+            type: external_zod_namespaceObject.z.literal('timezone'),
+            validateTimezone: external_zod_namespaceObject.z.boolean().default(true),
+            suggestedValues: external_zod_namespaceObject.z.array(external_zod_namespaceObject.z.string()).optional(),
+            restrictToSuggestedValues: external_zod_namespaceObject.z.boolean().default(false)
+        });
+        const jsonFieldSchema = fieldConfigSchema.extend({
+            type: external_zod_namespaceObject.z.literal('json'),
+            validateJson: external_zod_namespaceObject.z.boolean().default(true)
+        });
+        const stringArrayFieldSchema = fieldConfigSchema.extend({
+            type: external_zod_namespaceObject.z.literal('string[]')
+        });
+        const numberArrayFieldSchema = fieldConfigSchema.extend({
+            type: external_zod_namespaceObject.z.literal('number[]')
+        });
+        external_zod_namespaceObject.z.discriminatedUnion('type', [
+            stringFieldSchema,
+            numberFieldSchema,
+            booleanFieldSchema,
+            dateFieldSchema,
+            timezoneFieldSchema,
+            jsonFieldSchema,
+            stringArrayFieldSchema,
+            numberArrayFieldSchema
+        ]);
+        const COMMON_TIMEZONES = {
+            UTC: 'UTC',
+            GMT: 'GMT',
+            EASTERN: 'America/New_York',
+            CENTRAL: 'America/Chicago',
+            MOUNTAIN: 'America/Denver',
+            PACIFIC: 'America/Los_Angeles',
+            LONDON: 'Europe/London',
+            PARIS: 'Europe/Paris',
+            BERLIN: 'Europe/Berlin',
+            TOKYO: 'Asia/Tokyo',
+            SHANGHAI: 'Asia/Shanghai',
+            SINGAPORE: 'Asia/Singapore',
+            SYDNEY: 'Australia/Sydney',
+            SAO_PAULO: 'America/Sao_Paulo'
+        };
+        const external_base_x_namespaceObject = require("base-x");
+        var external_base_x_default = /*#__PURE__*/ __webpack_require__.n(external_base_x_namespaceObject);
+        const b58 = external_base_x_default()('123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz');
+        function generateId(prefix) {
+            const buf = crypto.getRandomValues(new Uint8Array(20));
+            const EPOCH_TIMESTAMP = 1700000000000;
+            const t = Date.now() - EPOCH_TIMESTAMP;
+            const high = Math.floor(t / 0x100000000);
+            const low = t >>> 0;
+            buf[0] = high >>> 24 & 255;
+            buf[1] = high >>> 16 & 255;
+            buf[2] = high >>> 8 & 255;
+            buf[3] = 255 & high;
+            buf[4] = low >>> 24 & 255;
+            buf[5] = low >>> 16 & 255;
+            buf[6] = low >>> 8 & 255;
+            buf[7] = 255 & low;
+            return `${prefix}_${b58.encode(buf)}`;
+        }
+        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
+            };
+        }
+        function consentGeoLocationRegistry({ adapter, ...ctx }) {
+            const { createWithHooks } = getWithHooks(adapter, ctx);
+            return {
+                createConsentGeoLocation: async (geoLocation, context)=>{
+                    const createdGeoLocation = await createWithHooks({
+                        data: {
+                            createdAt: new Date(),
+                            ...geoLocation
+                        },
+                        model: 'consentGeoLocation',
+                        customFn: void 0,
+                        context
+                    });
+                    if (!createdGeoLocation) throw new Error('Failed to create consent geo-location - operation returned null');
+                    return createdGeoLocation;
+                },
+                findConsentGeoLocationsByConsentId: async (consentId)=>{
+                    const geoLocations = await adapter.findMany({
+                        model: 'consentGeoLocation',
+                        where: [
+                            {
+                                field: 'consentId',
+                                value: consentId
+                            }
+                        ],
+                        sortBy: {
+                            field: 'createdAt',
+                            direction: 'desc'
+                        }
+                    });
+                    return geoLocations.map((geoLocation)=>validateEntityOutput('consentGeoLocation', geoLocation, ctx.options));
+                },
+                findConsentGeoLocationById: async (geoLocationId)=>{
+                    const geoLocation = await adapter.findOne({
+                        model: 'consentGeoLocation',
+                        where: [
+                            {
+                                field: 'id',
+                                value: geoLocationId
+                            }
+                        ]
+                    });
+                    return geoLocation ? validateEntityOutput('consentGeoLocation', geoLocation, ctx.options) : null;
+                }
+            };
+        }
+        const consentGeoLocationSchema = external_zod_namespaceObject.z.object({
+            id: external_zod_namespaceObject.z.string(),
+            consentId: external_zod_namespaceObject.z.string(),
+            ip: external_zod_namespaceObject.z.string().ip(),
+            country: external_zod_namespaceObject.z.string().optional(),
+            region: external_zod_namespaceObject.z.string().optional(),
+            city: external_zod_namespaceObject.z.string().optional(),
+            latitude: external_zod_namespaceObject.z.number().min(-90).max(90).optional(),
+            longitude: external_zod_namespaceObject.z.number().min(-180).max(180).optional(),
+            timezone: external_zod_namespaceObject.z.string().regex(/^[A-Za-z_]+\/[A-Za-z_]+$/).optional(),
+            createdAt: external_zod_namespaceObject.z.date().default(()=>new Date()),
+            updatedAt: external_zod_namespaceObject.z.date().default(()=>new Date())
+        });
+        function getConsentGeoLocationTable(options, geoLocationFields) {
+            const consentGeoLocationConfig = options.tables?.consentGeoLocation;
+            const consentConfig = options.tables?.consent;
+            return {
+                entityName: consentGeoLocationConfig?.entityName || 'consentGeoLocation',
+                entityPrefix: consentGeoLocationConfig?.entityPrefix || 'cgl',
+                schema: consentGeoLocationSchema,
+                fields: {
+                    consentId: {
+                        type: 'string',
+                        required: true,
+                        fieldName: consentGeoLocationConfig?.fields?.consentId || 'consentId',
+                        references: {
+                            model: consentConfig?.entityName || 'consent',
+                            field: 'id'
+                        }
+                    },
+                    ip: {
+                        type: 'string',
+                        required: true,
+                        fieldName: consentGeoLocationConfig?.fields?.ip || 'ip'
+                    },
+                    country: {
+                        type: 'string',
+                        required: false,
+                        fieldName: consentGeoLocationConfig?.fields?.country || 'country'
+                    },
+                    region: {
+                        type: 'string',
+                        required: false,
+                        fieldName: consentGeoLocationConfig?.fields?.region || 'region'
+                    },
+                    city: {
+                        type: 'string',
+                        required: false,
+                        fieldName: consentGeoLocationConfig?.fields?.city || 'city'
+                    },
+                    latitude: {
+                        type: 'number',
+                        required: false,
+                        fieldName: consentGeoLocationConfig?.fields?.latitude || 'latitude'
+                    },
+                    longitude: {
+                        type: 'number',
+                        required: false,
+                        fieldName: consentGeoLocationConfig?.fields?.longitude || 'longitude'
+                    },
+                    timezone: {
+                        type: 'string',
+                        required: false,
+                        fieldName: consentGeoLocationConfig?.fields?.timezone || 'timezone'
+                    },
+                    createdAt: {
+                        type: 'date',
+                        defaultValue: ()=>new Date(),
+                        required: true,
+                        fieldName: consentGeoLocationConfig?.fields?.createdAt || 'createdAt'
+                    },
+                    ...geoLocationFields || {},
+                    ...consentGeoLocationConfig?.additionalFields || {}
+                },
+                indexes: [
+                    {
+                        name: 'consent_id_index',
+                        fields: [
+                            'consentId'
+                        ]
+                    },
+                    {
+                        name: 'country_index',
+                        fields: [
+                            'country'
+                        ]
+                    },
+                    {
+                        name: 'created_at_index',
+                        fields: [
+                            'createdAt'
+                        ]
+                    }
+                ],
+                order: 4
+            };
+        }
+        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, updateWithHooks } = 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('Failed to create consent policy - operation returned null');
+                    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));
+                },
+                findPolicy: async (domainId, version)=>{
+                    const policies = await registry.findPolicies({
+                        domainId,
+                        version
+                    });
+                    return policies[0] || null;
+                },
+                findActiveConsentPolicies: async ()=>{
+                    const policies = await adapter.findMany({
+                        model: 'consentPolicy',
+                        where: [
+                            {
+                                field: 'isActive',
+                                value: true
+                            }
+                        ],
+                        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;
+                },
+                findConsentPolicyByVersion: async (version)=>{
+                    const policy = await adapter.findOne({
+                        model: 'consentPolicy',
+                        where: [
+                            {
+                                field: 'version',
+                                value: version
+                            }
+                        ]
+                    });
+                    return policy ? validateEntityOutput('consentPolicy', policy, ctx.options) : null;
+                },
+                updateConsentPolicy: async (policyId, data, context)=>{
+                    const policy = await updateWithHooks({
+                        data,
+                        where: [
+                            {
+                                field: 'id',
+                                value: policyId
+                            }
+                        ],
+                        model: 'consentPolicy',
+                        customFn: void 0,
+                        context
+                    });
+                    return policy ? validateEntityOutput('consentPolicy', policy, ctx.options) : null;
+                },
+                findOrCreatePolicy: async (name)=>{
+                    const normalizedSearchName = name.toLowerCase().trim();
+                    return adapter.transaction({
+                        callback: async (txAdapter)=>{
+                            const now = new Date();
+                            const txRegistry = policyRegistry({
+                                adapter: txAdapter,
+                                ...ctx
+                            });
+                            const matchingPolicies = await txAdapter.findMany({
+                                model: 'consentPolicy',
+                                where: [
+                                    {
+                                        field: 'isActive',
+                                        value: true
+                                    },
+                                    {
+                                        field: 'name',
+                                        value: normalizedSearchName,
+                                        operator: 'ilike'
+                                    }
+                                ],
+                                sortBy: {
+                                    field: 'effectiveDate',
+                                    direction: 'desc'
+                                },
+                                limit: 1
+                            });
+                            const latestPolicy = matchingPolicies[0] ? validateEntityOutput('consentPolicy', matchingPolicies[0], ctx.options) : null;
+                            if (latestPolicy) return latestPolicy;
+                            const { content: defaultContent, contentHash } = generatePolicyPlaceholder(name, now);
+                            return txRegistry.createConsentPolicy({
+                                version: '1.0.0',
+                                name: normalizedSearchName,
+                                effectiveDate: now,
+                                content: defaultContent,
+                                contentHash,
+                                isActive: true,
+                                updatedAt: now,
+                                expirationDate: null
+                            });
+                        }
+                    });
+                }
+            };
+            return registry;
+        }
+        const consentPolicySchema = external_zod_namespaceObject.z.object({
+            id: external_zod_namespaceObject.z.string(),
+            version: external_zod_namespaceObject.z.string(),
+            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'
+                    },
+                    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
+            };
+        }
+        function consentPurposeJunctionRegistry({ adapter, ...ctx }) {
+            const { createWithHooks, updateWithHooks } = getWithHooks(adapter, ctx);
+            return {
+                createConsentPurposeJunction: async (junction, context)=>{
+                    const createdJunction = await createWithHooks({
+                        data: {
+                            createdAt: new Date(),
+                            ...junction,
+                            status: 'active'
+                        },
+                        model: 'consentPurposeJunction',
+                        customFn: void 0,
+                        context
+                    });
+                    if (!createdJunction) throw new Error('Failed to create consent-purpose junction - operation returned null');
+                    return createdJunction;
+                },
+                findConsentPurposesByConsentId: async (consentId)=>{
+                    const junctions = await adapter.findMany({
+                        model: 'consentPurposeJunction',
+                        where: [
+                            {
+                                field: 'consentId',
+                                value: consentId
+                            }
+                        ],
+                        sortBy: {
+                            field: 'createdAt',
+                            direction: 'desc'
+                        }
+                    });
+                    return junctions.map((junction)=>validateEntityOutput('consentPurposeJunction', junction, ctx.options));
+                },
+                findConsentPurposesByPurposeId: async (purposeId)=>{
+                    const junctions = await adapter.findMany({
+                        model: 'consentPurposeJunction',
+                        where: [
+                            {
+                                field: 'purposeId',
+                                value: purposeId
+                            }
+                        ],
+                        sortBy: {
+                            field: 'createdAt',
+                            direction: 'desc'
+                        }
+                    });
+                    return junctions.map((junction)=>validateEntityOutput('consentPurposeJunction', junction, ctx.options));
+                },
+                updateConsentPurposeJunction: async (junctionId, status, context)=>{
+                    const junction = await updateWithHooks({
+                        data: {
+                            status,
+                            updatedAt: new Date()
+                        },
+                        where: [
+                            {
+                                field: 'id',
+                                value: junctionId
+                            }
+                        ],
+                        model: 'consentPurposeJunction',
+                        customFn: void 0,
+                        context
+                    });
+                    return junction ? validateEntityOutput('consentPurposeJunction', junction, ctx.options) : null;
+                },
+                deleteConsentPurposeJunctionsByConsentId: async (consentId)=>{
+                    try {
+                        await adapter.deleteMany({
+                            model: 'consentPurposeJunction',
+                            where: [
+                                {
+                                    field: 'consentId',
+                                    value: consentId
+                                }
+                            ]
+                        });
+                        return true;
+                    } catch (error) {
+                        ctx.logger.error('Error deleting consent-purpose junctions:', error);
+                        return false;
+                    }
+                }
+            };
+        }
+        const consentPurposeJunctionSchema = external_zod_namespaceObject.z.object({
+            id: external_zod_namespaceObject.z.string(),
+            consentId: external_zod_namespaceObject.z.string(),
+            consentPurposeId: external_zod_namespaceObject.z.string(),
+            status: external_zod_namespaceObject.z["enum"]([
+                'active',
+                'withdrawn'
+            ], {
+                errorMap: ()=>({
+                        message: "Status must be either 'active' or 'withdrawn'"
+                    })
+            }).default('active'),
+            metadata: external_zod_namespaceObject.z.record(external_zod_namespaceObject.z.union([
+                external_zod_namespaceObject.z.string(),
+                external_zod_namespaceObject.z.number(),
+                external_zod_namespaceObject.z.boolean()
+            ])).optional(),
+            createdAt: external_zod_namespaceObject.z.date().default(()=>new Date()),
+            updatedAt: external_zod_namespaceObject.z.date().default(()=>new Date())
+        });
+        function getPurposeJunctionTable(options, junctionFields) {
+            const purposeJunctionConfig = options.tables?.consentPurposeJunction;
+            const consentConfig = options.tables?.consent;
+            const purposeConfig = options.tables?.consentPurpose;
+            return {
+                entityName: purposeJunctionConfig?.entityName || 'consentPurposeJunction',
+                entityPrefix: purposeJunctionConfig?.entityPrefix || 'pjx',
+                schema: consentPurposeJunctionSchema,
+                fields: {
+                    consentId: {
+                        type: 'string',
+                        required: true,
+                        fieldName: purposeJunctionConfig?.fields?.consentId || 'consentId',
+                        references: {
+                            model: consentConfig?.entityName || 'consent',
+                            field: 'id'
+                        }
+                    },
+                    purposeId: {
+                        type: 'string',
+                        required: true,
+                        fieldName: purposeJunctionConfig?.fields?.purposeId || 'purposeId',
+                        references: {
+                            model: purposeConfig?.entityName || 'consentPurpose',
+                            field: 'id'
+                        }
+                    },
+                    status: {
+                        type: 'string',
+                        defaultValue: ()=>'active',
+                        required: true,
+                        fieldName: purposeJunctionConfig?.fields?.status || 'status'
+                    },
+                    metadata: {
+                        type: 'json',
+                        required: false,
+                        fieldName: purposeJunctionConfig?.fields?.metadata || 'metadata'
+                    },
+                    createdAt: {
+                        type: 'date',
+                        defaultValue: ()=>new Date(),
+                        required: true,
+                        fieldName: purposeJunctionConfig?.fields?.createdAt || 'createdAt'
+                    },
+                    updatedAt: {
+                        type: 'date',
+                        required: false,
+                        fieldName: purposeJunctionConfig?.fields?.updatedAt || 'updatedAt'
+                    },
+                    ...junctionFields || {},
+                    ...purposeJunctionConfig?.additionalFields || {}
+                },
+                uniqueConstraints: [
+                    {
+                        name: 'unique_consent_purpose',
+                        fields: [
+                            'consentId',
+                            'purposeId'
+                        ]
+                    }
+                ],
+                order: 4
+            };
+        }
+        function consentPurposeRegistry({ adapter, ...ctx }) {
+            const { createWithHooks, updateWithHooks } = 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('Failed to create consent consentPurpose - operation returned null');
+                    return validateEntityOutput('consentPurpose', createdPurpose, ctx.options);
+                },
+                findConsentPurposes: async (includeInactive)=>{
+                    const whereConditions = [];
+                    if (!includeInactive) whereConditions.push({
+                        field: 'isActive',
+                        value: true
+                    });
+                    const purposes = await adapter.findMany({
+                        model: 'consentPurpose',
+                        where: whereConditions,
+                        sortBy: {
+                            field: 'createdAt',
+                            direction: 'asc'
+                        }
+                    });
+                    return purposes.map((consentPurpose)=>validateEntityOutput('consentPurpose', consentPurpose, ctx.options));
+                },
+                findConsentPurposeById: async (purposeId)=>{
+                    const consentPurpose = await adapter.findOne({
+                        model: 'consentPurpose',
+                        where: [
+                            {
+                                field: 'id',
+                                value: purposeId
+                            }
+                        ]
+                    });
+                    return consentPurpose ? validateEntityOutput('consentPurpose', consentPurpose, ctx.options) : null;
+                },
+                findConsentPurposeByCode: async (code)=>{
+                    const consentPurpose = await adapter.findOne({
+                        model: 'consentPurpose',
+                        where: [
+                            {
+                                field: 'code',
+                                value: code
+                            }
+                        ]
+                    });
+                    return consentPurpose ? validateEntityOutput('consentPurpose', consentPurpose, ctx.options) : null;
+                },
+                updateConsentPurpose: async (purposeId, data, context)=>{
+                    const consentPurpose = await updateWithHooks({
+                        data: {
+                            ...data,
+                            updatedAt: new Date()
+                        },
+                        where: [
+                            {
+                                field: 'id',
+                                value: purposeId
+                            }
+                        ],
+                        model: 'consentPurpose',
+                        context
+                    });
+                    return consentPurpose ? validateEntityOutput('consentPurpose', consentPurpose, ctx.options) : null;
+                }
+            };
+        }
+        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
+            };
+        }
+        function consentRecordRegistry({ adapter, ...ctx }) {
+            const { createWithHooks } = getWithHooks(adapter, ctx);
+            return {
+                createConsentRecord: async (record, context)=>{
+                    const createdRecord = await createWithHooks({
+                        data: {
+                            createdAt: record.createdAt || new Date(),
+                            updatedAt: record.updatedAt || new Date(),
+                            ...record
+                        },
+                        model: 'consentRecord',
+                        customFn: void 0,
+                        context
+                    });
+                    if (!createdRecord) throw new Error('Failed to create consent record - operation returned null');
+                    return createdRecord;
+                },
+                findConsentRecords: async (subjectId, consentId, actionType, limit)=>{
+                    const whereConditions = [];
+                    if (subjectId) whereConditions.push({
+                        field: 'subjectId',
+                        value: subjectId
+                    });
+                    if (consentId) whereConditions.push({
+                        field: 'consentId',
+                        value: consentId
+                    });
+                    if (actionType) whereConditions.push({
+                        field: 'actionType',
+                        value: actionType
+                    });
+                    const records = await adapter.findMany({
+                        model: 'consentRecord',
+                        where: whereConditions,
+                        sortBy: {
+                            field: 'createdAt',
+                            direction: 'desc'
+                        },
+                        limit
+                    });
+                    return records.map((record)=>validateEntityOutput('consentRecord', record, ctx.options));
+                },
+                findConsentRecordById: async (recordId)=>{
+                    const record = await adapter.findOne({
+                        model: 'consentRecord',
+                        where: [
+                            {
+                                field: 'id',
+                                value: recordId
+                            }
+                        ]
+                    });
+                    return record ? validateEntityOutput('consentRecord', record, ctx.options) : null;
+                },
+                findConsentRecordsBySubjectId: async (subjectId, limit)=>{
+                    const records = await adapter.findMany({
+                        model: 'consentRecord',
+                        where: [
+                            {
+                                field: 'subjectId',
+                                value: subjectId
+                            }
+                        ],
+                        sortBy: {
+                            field: 'createdAt',
+                            direction: 'desc'
+                        },
+                        limit
+                    });
+                    return records.map((record)=>validateEntityOutput('consentRecord', record, ctx.options));
+                },
+                findConsentRecordsByConsentId: async (consentId, limit)=>{
+                    const records = await adapter.findMany({
+                        model: 'consentRecord',
+                        where: [
+                            {
+                                field: 'consentId',
+                                value: consentId
+                            }
+                        ],
+                        sortBy: {
+                            field: 'createdAt',
+                            direction: 'desc'
+                        },
+                        limit
+                    });
+                    return records.map((record)=>validateEntityOutput('consentRecord', record, ctx.options));
+                }
+            };
+        }
+        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
+            };
+        }
+        function consentWithdrawalRegistry({ adapter, ...ctx }) {
+            const { createWithHooks } = getWithHooks(adapter, ctx);
+            return {
+                createConsentWithdrawal: async (consentWithdrawal, context)=>{
+                    const createdWithdrawal = await createWithHooks({
+                        data: {
+                            createdAt: new Date(),
+                            ...consentWithdrawal
+                        },
+                        model: 'consentWithdrawal',
+                        customFn: void 0,
+                        context
+                    });
+                    if (!createdWithdrawal) throw new Error('Failed to create consent withdrawal - operation returned null');
+                    return validateEntityOutput('consentWithdrawal', createdWithdrawal, ctx.options);
+                },
+                findConsentWithdrawals: async (subjectId, consentId, limit)=>{
+                    const whereConditions = [];
+                    if (subjectId) whereConditions.push({
+                        field: 'subjectId',
+                        value: subjectId
+                    });
+                    if (consentId) whereConditions.push({
+                        field: 'consentId',
+                        value: consentId
+                    });
+                    const consentWithdrawals = await adapter.findMany({
+                        model: 'consentWithdrawal',
+                        where: whereConditions,
+                        sortBy: {
+                            field: 'createdAt',
+                            direction: 'desc'
+                        },
+                        limit
+                    });
+                    return consentWithdrawals.map((consentWithdrawal)=>validateEntityOutput('consentWithdrawal', consentWithdrawal, ctx.options));
+                },
+                findConsentWithdrawalById: async (withdrawalId)=>{
+                    const consentWithdrawal = await adapter.findOne({
+                        model: 'consentWithdrawal',
+                        where: [
+                            {
+                                field: 'id',
+                                value: withdrawalId
+                            }
+                        ]
+                    });
+                    return consentWithdrawal ? validateEntityOutput('consentWithdrawal', consentWithdrawal, ctx.options) : null;
+                },
+                findConsentWithdrawalsBySubjectId: async (subjectId, limit)=>{
+                    const consentWithdrawals = await adapter.findMany({
+                        model: 'consentWithdrawal',
+                        where: [
+                            {
+                                field: 'subjectId',
+                                value: subjectId
+                            }
+                        ],
+                        sortBy: {
+                            field: 'createdAt',
+                            direction: 'desc'
+                        },
+                        limit
+                    });
+                    return consentWithdrawals.map((consentWithdrawal)=>validateEntityOutput('consentWithdrawal', consentWithdrawal, ctx.options));
+                },
+                findConsentWithdrawalByConsentId: async (consentId)=>{
+                    const consentWithdrawal = await adapter.findOne({
+                        model: 'consentWithdrawal',
+                        where: [
+                            {
+                                field: 'consentId',
+                                value: consentId
+                            }
+                        ],
+                        sortBy: {
+                            field: 'createdAt',
+                            direction: 'desc'
+                        }
+                    });
+                    return consentWithdrawal ? validateEntityOutput('consentWithdrawal', consentWithdrawal, ctx.options) : null;
+                }
+            };
+        }
+        const consentWithdrawalSchema = external_zod_namespaceObject.z.object({
+            id: external_zod_namespaceObject.z.string(),
+            consentId: external_zod_namespaceObject.z.string(),
+            subjectId: external_zod_namespaceObject.z.string(),
+            withdrawalReason: external_zod_namespaceObject.z.string().optional(),
+            withdrawalMethod: external_zod_namespaceObject.z["enum"]([
+                'subject-initiated',
+                'automatic-expiry',
+                'admin',
+                'api',
+                'other'
+            ]).default('subject-initiated'),
+            ipAddress: external_zod_namespaceObject.z.string().optional(),
+            userAgent: external_zod_namespaceObject.z.string().optional(),
+            metadata: 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 getConsentWithdrawalTable(options, withdrawalFields) {
+            const consentWithdrawalConfig = options.tables?.consentWithdrawal;
+            const consentConfig = options.tables?.consent;
+            const subjectConfig = options.tables?.subject;
+            return {
+                entityName: consentWithdrawalConfig?.entityName || 'consentWithdrawal',
+                entityPrefix: consentWithdrawalConfig?.entityPrefix || 'wdr',
+                schema: consentWithdrawalSchema,
+                fields: {
+                    consentId: {
+                        type: 'string',
+                        required: true,
+                        fieldName: consentWithdrawalConfig?.fields?.consentId || 'consentId',
+                        references: {
+                            model: consentConfig?.entityName || 'consent',
+                            field: 'id'
+                        }
+                    },
+                    subjectId: {
+                        type: 'string',
+                        required: true,
+                        fieldName: consentWithdrawalConfig?.fields?.subjectId || 'subjectId',
+                        references: {
+                            model: subjectConfig?.entityName || 'subject',
+                            field: 'id'
+                        }
+                    },
+                    withdrawalReason: {
+                        type: 'string',
+                        required: false,
+                        fieldName: consentWithdrawalConfig?.fields?.withdrawalReason || 'withdrawalReason'
+                    },
+                    withdrawalMethod: {
+                        type: 'string',
+                        defaultValue: ()=>'subject-initiated',
+                        required: true,
+                        fieldName: consentWithdrawalConfig?.fields?.withdrawalMethod || 'withdrawalMethod'
+                    },
+                    ipAddress: {
+                        type: 'string',
+                        required: false,
+                        fieldName: consentWithdrawalConfig?.fields?.ipAddress || 'ipAddress'
+                    },
+                    userAgent: {
+                        type: 'string',
+                        required: false,
+                        fieldName: consentWithdrawalConfig?.fields?.userAgent || 'userAgent'
+                    },
+                    metadata: {
+                        type: 'json',
+                        required: false,
+                        fieldName: consentWithdrawalConfig?.fields?.metadata || 'metadata'
+                    },
+                    createdAt: {
+                        type: 'date',
+                        defaultValue: ()=>new Date(),
+                        required: true,
+                        fieldName: consentWithdrawalConfig?.fields?.createdAt || 'createdAt'
+                    },
+                    ...withdrawalFields || {},
+                    ...consentWithdrawalConfig?.additionalFields || {}
+                },
+                uniqueConstraints: consentWithdrawalConfig?.preventMultipleWithdrawals !== false ? [
+                    {
+                        name: 'unique_consent_withdrawal',
+                        fields: [
+                            'consentId'
+                        ]
+                    }
+                ] : [],
+                indexes: [
+                    {
+                        name: 'subject_id_index',
+                        fields: [
+                            'subjectId'
+                        ]
+                    },
+                    {
+                        name: 'created_at_index',
+                        fields: [
+                            'createdAt'
+                        ]
+                    }
+                ],
+                order: 4
+            };
+        }
+        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('Failed to create consent - operation returned null');
+                    return createdConsent;
+                },
+                findConsents: async (params = {})=>{
+                    const whereConditions = [];
+                    if (!params.includeInactive) whereConditions.push({
+                        field: 'isActive',
+                        value: true
+                    });
+                    if (params.subjectId) whereConditions.push({
+                        field: 'subjectId',
+                        value: params.subjectId
+                    });
+                    if (params.domainId) whereConditions.push({
+                        field: 'domainId',
+                        value: params.domainId
+                    });
+                    if (params.status) whereConditions.push({
+                        field: 'status',
+                        value: params.status
+                    });
+                    if (params.purposeIds && params.purposeIds.length > 0) whereConditions.push({
+                        field: 'purposeIds',
+                        operator: 'contains',
+                        value: params.purposeIds
+                    });
+                    const consents = await adapter.findMany({
+                        model: 'consent',
+                        where: whereConditions,
+                        sortBy: {
+                            field: 'givenAt',
+                            direction: 'desc'
+                        }
+                    });
+                    return consents.map((consent)=>validateEntityOutput('consent', consent, ctx.options));
+                },
+                findConsentById: async (consentId)=>{
+                    const consent = await adapter.findOne({
+                        model: 'consent',
+                        where: [
+                            {
+                                field: 'id',
+                                value: consentId
+                            }
+                        ]
+                    });
+                    return consent ? validateEntityOutput('consent', consent, ctx.options) : null;
+                },
+                findConsentsBySubjectId: async (subjectId)=>{
+                    const consents = await adapter.findMany({
+                        model: 'consent',
+                        where: [
+                            {
+                                field: 'subjectId',
+                                value: subjectId
+                            }
+                        ],
+                        sortBy: {
+                            field: 'givenAt',
+                            direction: 'desc'
+                        }
+                    });
+                    return consents.map((consent)=>validateEntityOutput('consent', consent, ctx.options));
+                },
+                findConsentsByDomainId: async (domainId)=>{
+                    const consents = await adapter.findMany({
+                        model: 'consent',
+                        where: [
+                            {
+                                field: 'domainId',
+                                value: domainId
+                            }
+                        ],
+                        sortBy: {
+                            field: 'givenAt',
+                            direction: 'desc'
+                        }
+                    });
+                    return consents.map((consent)=>validateEntityOutput('consent', consent, ctx.options));
+                },
+                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;
+                },
+                updateWithdrawal: async (consentId, withdrawalReason, context)=>{
+                    const updateData = {
+                        status: 'withdrawn'
+                    };
+                    if (withdrawalReason) updateData.withdrawalReason = withdrawalReason;
+                    const consent = await updateWithHooks({
+                        data: updateData,
+                        where: [
+                            {
+                                field: 'id',
+                                value: consentId
+                            }
+                        ],
+                        model: 'consent',
+                        context
+                    });
+                    return consent ? validateEntityOutput('consent', consent, ctx.options) : null;
+                },
+                revokeConsent: async ({ consentId, reason, actor, metadata, context })=>{
+                    const consent = await registry.findConsentById(consentId);
+                    if (!consent) throw new Error('Consent not found');
+                    const updateData = {
+                        status: 'withdrawn',
+                        withdrawalReason: reason,
+                        metadata: {
+                            ...consent.metadata,
+                            consentWithdrawal: {
+                                actor,
+                                timestamp: new Date().toISOString(),
+                                ...metadata
+                            }
+                        }
+                    };
+                    return registry.updateConsent(consentId, updateData, context);
+                },
+                getRecords: async (consentId)=>{
+                    const records = await adapter.findMany({
+                        model: 'consentRecord',
+                        where: [
+                            {
+                                field: 'consentId',
+                                value: consentId
+                            }
+                        ],
+                        sortBy: {
+                            field: 'createdAt',
+                            direction: 'desc'
+                        }
+                    });
+                    return records.map((record)=>validateEntityOutput('consentRecord', record, ctx.options));
+                },
+                getWithdrawals: async (consentId)=>{
+                    const consentWithdrawals = await adapter.findMany({
+                        model: 'consentWithdrawal',
+                        where: [
+                            {
+                                field: 'consentId',
+                                value: consentId
+                            }
+                        ],
+                        sortBy: {
+                            field: 'createdAt',
+                            direction: 'desc'
+                        }
+                    });
+                    return consentWithdrawals.map((consentWithdrawal)=>validateEntityOutput('consentWithdrawal', consentWithdrawal, ctx.options));
+                }
+            };
+            return registry;
+        }
+        const consentHistorySchema = external_zod_namespaceObject.z.object({
+            actionType: external_zod_namespaceObject.z["enum"]([
+                'given',
+                'withdrawn',
+                'updated',
+                'expired'
+            ]),
+            timestamp: external_zod_namespaceObject.z.date(),
+            details: external_zod_namespaceObject.z.record(external_zod_namespaceObject.z.unknown()).optional(),
+            previousState: external_zod_namespaceObject.z.record(external_zod_namespaceObject.z.unknown()).optional(),
+            newState: external_zod_namespaceObject.z.record(external_zod_namespaceObject.z.unknown()).optional()
+        });
+        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()).optional(),
+            policyId: external_zod_namespaceObject.z.string().optional(),
+            ipAddress: external_zod_namespaceObject.z.string().optional(),
+            userAgent: external_zod_namespaceObject.z.string().optional(),
+            status: external_zod_namespaceObject.z["enum"]([
+                'active',
+                'withdrawn',
+                'expired'
+            ]).default('active'),
+            withdrawalReason: external_zod_namespaceObject.z.string().optional(),
+            givenAt: external_zod_namespaceObject.z.date().default(()=>new Date()),
+            validUntil: external_zod_namespaceObject.z.date().optional(),
+            isActive: external_zod_namespaceObject.z.boolean().default(true),
+            history: external_zod_namespaceObject.z.array(consentHistorySchema).default([])
+        });
+        function getConsentTable(options, consentFields) {
+            const consentConfig = options.tables?.consent;
+            const subjectConfig = options.tables?.subject;
+            const domainConfig = options.tables?.domain;
+            const policyConfig = options.tables?.consentPolicy;
+            const purposeConfig = options.tables?.consentPurpose;
+            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',
+                        references: {
+                            model: purposeConfig?.entityName || 'consentPurpose',
+                            field: 'id',
+                            type: 'array'
+                        }
+                    },
+                    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
+            };
+        }
+        function domainRegistry({ adapter, ...ctx }) {
+            const { createWithHooks, updateWithHooks } = 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('Failed to create domain - operation returned null');
+                    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 src_error.kO('Failed to create domain', {
+                        code: src_error.H8.INTERNAL_SERVER_ERROR,
+                        status: 503
+                    });
+                    return domain;
+                },
+                findDomains: async (params = {})=>{
+                    const whereConditions = [];
+                    if (!params.includeInactive) whereConditions.push({
+                        field: 'isActive',
+                        value: true
+                    });
+                    if (params.name) whereConditions.push({
+                        field: 'name',
+                        value: params.name
+                    });
+                    const domains = await adapter.findMany({
+                        model: 'domain',
+                        where: whereConditions,
+                        sortBy: {
+                            field: 'name',
+                            direction: 'asc'
+                        }
+                    });
+                    return domains.map((domain)=>validateEntityOutput('domain', domain, ctx.options));
+                },
+                findDomain: async (name)=>{
+                    const domains = await registry.findDomains({
+                        name,
+                        includeInactive: false
+                    });
+                    return domains[0] || null;
+                },
+                findDomainById: async (domainId)=>{
+                    const domain = await adapter.findOne({
+                        model: 'domain',
+                        where: [
+                            {
+                                field: 'id',
+                                value: domainId
+                            }
+                        ]
+                    });
+                    return domain ? validateEntityOutput('domain', domain, ctx.options) : null;
+                },
+                findDomainByName: async (name)=>{
+                    const domain = await adapter.findOne({
+                        model: 'domain',
+                        where: [
+                            {
+                                field: 'name',
+                                value: name
+                            }
+                        ]
+                    });
+                    return domain ? validateEntityOutput('domain', domain, ctx.options) : null;
+                },
+                updateDomain: async (domainId, data, context)=>{
+                    const domain = await updateWithHooks({
+                        data: {
+                            ...data,
+                            updatedAt: new Date()
+                        },
+                        where: [
+                            {
+                                field: 'id',
+                                value: domainId
+                            }
+                        ],
+                        model: 'domain',
+                        customFn: void 0,
+                        context
+                    });
+                    return domain ? validateEntityOutput('domain', domain, ctx.options) : null;
+                },
+                verifyDomain: async (domainName)=>{
+                    const domain = await adapter.findOne({
+                        model: 'domain',
+                        where: [
+                            {
+                                field: 'name',
+                                value: domainName
+                            },
+                            {
+                                field: 'isActive',
+                                value: true
+                            }
+                        ]
+                    });
+                    return !!domain;
+                }
+            };
+            return registry;
+        }
+        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
+            };
+        }
+        function geoLocationRegistry({ adapter, ...ctx }) {
+            const { createWithHooks } = getWithHooks(adapter, ctx);
+            return {
+                createGeoLocation: async (location, context)=>{
+                    const createdLocation = await createWithHooks({
+                        data: {
+                            createdAt: new Date(),
+                            ...location
+                        },
+                        model: 'consentGeoLocation',
+                        customFn: void 0,
+                        context
+                    });
+                    if (!createdLocation) throw new Error('Failed to create geo-location - operation returned null');
+                    return createdLocation;
+                },
+                findGeoLocations: async (filter)=>{
+                    const whereConditions = [];
+                    if (filter?.countryCode) whereConditions.push({
+                        field: 'countryCode',
+                        value: filter.countryCode
+                    });
+                    if (filter?.regionCode) whereConditions.push({
+                        field: 'regionCode',
+                        value: filter.regionCode
+                    });
+                    const locations = await adapter.findMany({
+                        model: 'geoLocation',
+                        where: whereConditions,
+                        sortBy: {
+                            field: 'countryName',
+                            direction: 'asc'
+                        }
+                    });
+                    return locations.map((location)=>validateEntityOutput('consentGeoLocation', location, ctx.options));
+                },
+                findGeoLocationById: async (locationId)=>{
+                    const location = await adapter.findOne({
+                        model: 'geoLocation',
+                        where: [
+                            {
+                                field: 'id',
+                                value: locationId
+                            }
+                        ]
+                    });
+                    return location ? validateEntityOutput('consentGeoLocation', location, ctx.options) : null;
+                },
+                findGeoLocationsByCountry: async (countryCode)=>{
+                    const locations = await adapter.findMany({
+                        model: 'geoLocation',
+                        where: [
+                            {
+                                field: 'countryCode',
+                                value: countryCode
+                            }
+                        ],
+                        sortBy: {
+                            field: 'regionName',
+                            direction: 'asc'
+                        }
+                    });
+                    return locations.map((location)=>validateEntityOutput('consentGeoLocation', location, ctx.options));
+                }
+            };
+        }
+        const geoLocationSchema = external_zod_namespaceObject.z.object({
+            id: external_zod_namespaceObject.z.string(),
+            countryCode: external_zod_namespaceObject.z.string().length(2).toUpperCase(),
+            countryName: external_zod_namespaceObject.z.string(),
+            regionCode: external_zod_namespaceObject.z.string().optional(),
+            regionName: external_zod_namespaceObject.z.string().optional(),
+            regulatoryZones: external_zod_namespaceObject.z.array(external_zod_namespaceObject.z["enum"]([
+                'GDPR',
+                'CCPA',
+                'CPRA',
+                'LGPD',
+                'PIPEDA'
+            ])).optional(),
+            createdAt: external_zod_namespaceObject.z.date().default(()=>new Date())
+        });
+        function getGeoLocationTable(options, geoLocationFields) {
+            const geoLocationConfig = options.tables?.geoLocation;
+            return {
+                entityName: geoLocationConfig?.entityName || 'geoLocation',
+                entityPrefix: geoLocationConfig?.entityPrefix || 'geo',
+                schema: geoLocationSchema,
+                fields: {
+                    countryCode: {
+                        type: 'string',
+                        required: true,
+                        fieldName: geoLocationConfig?.fields?.countryCode || 'countryCode'
+                    },
+                    countryName: {
+                        type: 'string',
+                        required: true,
+                        fieldName: geoLocationConfig?.fields?.countryName || 'countryName'
+                    },
+                    regionCode: {
+                        type: 'string',
+                        required: false,
+                        fieldName: geoLocationConfig?.fields?.regionCode || 'regionCode'
+                    },
+                    regionName: {
+                        type: 'string',
+                        required: false,
+                        fieldName: geoLocationConfig?.fields?.regionName || 'regionName'
+                    },
+                    regulatoryZones: {
+                        type: 'json',
+                        required: false,
+                        fieldName: geoLocationConfig?.fields?.regulatoryZones || 'regulatoryZones',
+                        transformer: {
+                            input: (value)=>JSON.stringify(value),
+                            output: (value)=>{
+                                try {
+                                    return JSON.parse(value);
+                                } catch  {
+                                    return [];
+                                }
+                            }
+                        }
+                    },
+                    createdAt: {
+                        type: 'date',
+                        defaultValue: ()=>new Date(),
+                        required: true,
+                        fieldName: geoLocationConfig?.fields?.createdAt || 'createdAt'
+                    },
+                    ...geoLocationFields || {},
+                    ...geoLocationConfig?.additionalFields || {}
+                },
+                indexes: [
+                    {
+                        name: 'country_code_index',
+                        fields: [
+                            'countryCode'
+                        ]
+                    },
+                    {
+                        name: 'region_code_index',
+                        fields: [
+                            'regionCode'
+                        ]
+                    },
+                    {
+                        name: 'created_at_index',
+                        fields: [
+                            'createdAt'
+                        ]
+                    }
+                ],
+                order: 1
+            };
+        }
+        function subjectRegistry({ adapter, ...ctx }) {
+            const { createWithHooks, updateWithHooks } = 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?.info('Subject validation failed: One or both subjects not found', {
+                                providedSubjectId: subjectId,
+                                providedExternalId: externalSubjectId,
+                                subjectByIdFound: !!subjectById,
+                                subjectByExternalIdFound: !!subjectByExternalId
+                            });
+                            throw new src_error.kO('The specified subject could not be found. Please verify the subject identifiers and try again.', {
+                                code: src_error.H8.NOT_FOUND,
+                                status: 404,
+                                data: {
+                                    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 src_error.kO('The provided subjectId and externalSubjectId do not match the same subject. Please ensure both identifiers refer to the same subject.', {
+                                code: src_error.H8.CONFLICT,
+                                status: 409,
+                                data: {
+                                    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 src_error.kO('Subject not found', {
+                            code: src_error.H8.NOT_FOUND,
+                            status: 404
+                        });
+                    }
+                    if (externalSubjectId) try {
+                        const subject = await this.findSubjectByExternalId(externalSubjectId);
+                        if (subject) {
+                            ctx.logger?.debug('Found existing subject by external ID', {
+                                externalSubjectId
+                            });
+                            return subject;
+                        }
+                        ctx.logger?.info('Creating new subject with external ID', {
+                            externalSubjectId
+                        });
+                        return await this.createSubject({
+                            externalId: externalSubjectId,
+                            identityProvider: 'external',
+                            lastIpAddress: ipAddress,
+                            isIdentified: true
+                        }, context);
+                    } catch (error) {
+                        if (error instanceof Error && error.message.includes('unique constraint')) {
+                            ctx.logger?.info('Handling duplicate key violation for external ID', {
+                                externalSubjectId
+                            });
+                            const subject = await this.findSubjectByExternalId(externalSubjectId);
+                            if (subject) return subject;
+                        }
+                        ctx.logger?.error('Failed to create or find subject with external ID', {
+                            externalSubjectId,
+                            error: error instanceof Error ? error.message : 'Unknown error'
+                        });
+                        throw new src_error.kO('Failed to create or find subject with external ID', {
+                            code: src_error.H8.INTERNAL_SERVER_ERROR,
+                            status: 500,
+                            data: {
+                                error: error instanceof Error ? error.message : 'Unknown error'
+                            }
+                        });
+                    }
+                    try {
+                        ctx.logger?.info('Creating new anonymous subject');
+                        return await this.createSubject({
+                            externalId: null,
+                            identityProvider: 'anonymous',
+                            lastIpAddress: ipAddress,
+                            isIdentified: false
+                        }, context);
+                    } catch (error) {
+                        ctx.logger?.error('Failed to create anonymous subject', {
+                            ipAddress,
+                            error: error instanceof Error ? error.message : 'Unknown error'
+                        });
+                        throw new src_error.kO('Failed to create anonymous subject', {
+                            code: src_error.H8.INTERNAL_SERVER_ERROR,
+                            status: 500,
+                            data: {
+                                error: error instanceof Error ? error.message : 'Unknown error'
+                            }
+                        });
+                    }
+                },
+                findSubjectById: async (subjectId)=>{
+                    const subject = await adapter.findOne({
+                        model: 'subject',
+                        where: [
+                            {
+                                field: 'id',
+                                value: subjectId
+                            }
+                        ]
+                    });
+                    return subject ? validateEntityOutput('subject', subject, ctx.options) : null;
+                },
+                findSubjectByExternalId: async (externalId)=>{
+                    const subject = await adapter.findOne({
+                        model: 'subject',
+                        where: [
+                            {
+                                field: 'externalId',
+                                value: externalId
+                            }
+                        ]
+                    });
+                    return subject ? validateEntityOutput('subject', subject, ctx.options) : null;
+                },
+                updateSubject: async (subjectId, data, context)=>{
+                    const subject = await updateWithHooks({
+                        data: {
+                            ...data,
+                            updatedAt: new Date()
+                        },
+                        where: [
+                            {
+                                field: 'id',
+                                value: subjectId
+                            }
+                        ],
+                        model: 'subject',
+                        customFn: void 0,
+                        context
+                    });
+                    return subject ? validateEntityOutput('subject', subject, ctx.options) : null;
+                },
+                deleteSubject: async (subjectId)=>{
+                    await adapter.transaction({
+                        callback: async (tx)=>{
+                            await tx.update({
+                                model: 'subject',
+                                where: [
+                                    {
+                                        field: 'id',
+                                        value: subjectId
+                                    }
+                                ],
+                                update: {
+                                    status: 'deleted',
+                                    updatedAt: new Date()
+                                }
+                            });
+                            await tx.deleteMany({
+                                model: 'consent',
+                                where: [
+                                    {
+                                        field: 'subjectId',
+                                        value: subjectId
+                                    }
+                                ]
+                            });
+                        }
+                    });
+                }
+            };
+        }
+        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 external_kysely_namespaceObject = require("kysely");
+        function dialect_getDatabaseType(db) {
+            if (!db) return null;
+            if ('dialect' in db) return dialect_getDatabaseType(db.dialect);
+            if ('createDriver' in db) {
+                if (db instanceof external_kysely_namespaceObject.SqliteDialect) return 'sqlite';
+                if (db instanceof external_kysely_namespaceObject.MysqlDialect) return 'mysql';
+                if (db instanceof external_kysely_namespaceObject.PostgresDialect) return 'postgres';
+                if (db instanceof external_kysely_namespaceObject.MssqlDialect) return 'mssql';
+            }
+            if ('aggregate' in db) return 'sqlite';
+            if ('getConnection' in db) return 'mysql';
+            if ('connect' in db) return 'postgres';
+            return null;
+        }
+        const dialect_createKyselyAdapter = async (config)=>{
+            const db = config.database;
+            if (!db) return {
+                kysely: null,
+                databaseType: null
+            };
+            if ('db' in db) {
+                const kyselyConfig = db;
+                return {
+                    kysely: kyselyConfig.db,
+                    databaseType: kyselyConfig.type
+                };
+            }
+            if ('dialect' in db) {
+                const dialectConfig = db;
+                return {
+                    kysely: new external_kysely_namespaceObject.Kysely({
+                        dialect: dialectConfig.dialect
+                    }),
+                    databaseType: dialectConfig.type
+                };
+            }
+            let dialect;
+            const databaseType = dialect_getDatabaseType(db);
+            if ('createDriver' in db) dialect = db;
+            if ('aggregate' in db) dialect = new external_kysely_namespaceObject.SqliteDialect({
+                database: db
+            });
+            if ('getConnection' in db) dialect = new external_kysely_namespaceObject.MysqlDialect({
+                pool: db
+            });
+            if ('connect' in db) dialect = new external_kysely_namespaceObject.PostgresDialect({
+                pool: db
+            });
+            return {
+                kysely: dialect ? new external_kysely_namespaceObject.Kysely({
+                    dialect
+                }) : null,
+                databaseType
+            };
+        };
+        function applyDefaultValue(inputValue, field, operation) {
+            if ('update' === operation) return inputValue;
+            if (null == inputValue && field.defaultValue) {
+                if ('function' == typeof field.defaultValue) return field.defaultValue();
+                return field.defaultValue;
+            }
+            return inputValue;
+        }
+        const createEntityTransformer = (db, options, config)=>{
+            const schema = definition_getConsentTables(options);
+            function getField(model, field) {
+                if ('id' === field) return field;
+                const modelFields = schema[model]?.fields;
+                const f = modelFields ? modelFields[field] : void 0;
+                if (!f) console.log('Field not found', model, field);
+                return f?.fieldName || field;
+            }
+            function transformValueToDB(value, model, field) {
+                if ('id' === field) return value;
+                const { type = 'sqlite' } = config || {};
+                const modelFields = schema[model]?.fields;
+                const f = modelFields ? modelFields[field] : void 0;
+                if (f?.type === 'boolean' && ('sqlite' === type || 'mssql' === type) && null != value) return value ? 1 : 0;
+                if (f?.type === 'date' && value && value instanceof Date) return 'sqlite' === type ? value.toISOString() : value;
+                if (f?.type === 'json' && null != value) {
+                    if ('postgres' === type || 'mysql' === type) return value;
+                    return external_superjson_default().stringify(value);
+                }
+                return value;
+            }
+            function transformValueFromDB(value, model, field) {
+                const { type = 'sqlite' } = config || {};
+                const modelFields = schema[model]?.fields;
+                const f = modelFields ? modelFields[field] : void 0;
+                if (f?.type === 'boolean' && ('sqlite' === type || 'mssql' === type) && null !== value) return 1 === value;
+                if (f?.type === 'date' && value) return new Date(value);
+                if (f?.type === 'json' && null != value) {
+                    if (('postgres' === type || 'mysql' === type) && 'object' == typeof value) return value;
+                    if ('string' == typeof value) try {
+                        return external_superjson_default().parse(value);
+                    } catch  {
+                        try {
+                            return JSON.parse(value);
+                        } catch  {}
+                    }
+                }
+                return value;
+            }
+            function getEntityName(model) {
+                return schema[model].entityName;
+            }
+            return {
+                transformInput (data, model, action) {
+                    const transformedData = {};
+                    if ('create' === action) transformedData.id = data.id || (options.advanced?.generateId ? options.advanced.generateId({
+                        model
+                    }) : generateId(schema[model].entityPrefix));
+                    const fields = schema[model].fields;
+                    for(const field in fields)if (Object.hasOwn(fields, field)) {
+                        const value = data[field];
+                        const fieldInfo = fields[field];
+                        const fieldName = fieldInfo?.fieldName || field;
+                        if (fieldInfo) transformedData[fieldName] = applyDefaultValue(transformValueToDB(value, model, field), fieldInfo, action);
+                    }
+                    return transformedData;
+                },
+                transformOutput (data, model, select = []) {
+                    if (!data) return null;
+                    const transformedData = {};
+                    if (data.id && (0 === select.length || select.includes('id'))) transformedData.id = data.id;
+                    const tableSchema = schema[model]?.fields;
+                    for(const key in tableSchema){
+                        if (select.length && !select.includes(key)) continue;
+                        const field = tableSchema[key];
+                        if (field) transformedData[key] = transformValueFromDB(data[field.fieldName || key], model, key);
+                    }
+                    return transformedData;
+                },
+                convertWhereClause (model, whereConditions) {
+                    if (!whereConditions || 0 === whereConditions.length) return {
+                        and: null,
+                        or: null
+                    };
+                    const conditions = {
+                        and: [],
+                        or: []
+                    };
+                    for (const condition of whereConditions){
+                        let { field: _field, value, operator = '=', connector = 'AND' } = condition;
+                        const fieldString = getField(model, _field);
+                        value = transformValueToDB(value, model, _field);
+                        const expr = (eb)=>{
+                            const dbField = fieldString;
+                            if ('in' === operator.toLowerCase()) return eb(dbField, 'in', Array.isArray(value) ? value : [
+                                value
+                            ]);
+                            if ('contains' === operator) return eb(dbField, 'like', `%${value}%`);
+                            if ('starts_with' === operator) return eb(dbField, 'like', `${value}%`);
+                            if ('ends_with' === operator) return eb(dbField, 'like', `%${value}`);
+                            if ('ilike' === operator) {
+                                const lowerField = eb.fn('lower', [
+                                    dbField
+                                ]);
+                                const lowerValue = eb.fn('lower', [
+                                    eb.val(value?.toString())
+                                ]);
+                                return eb(lowerField, 'like', lowerValue);
+                            }
+                            if ('eq' === operator) return eb(dbField, '=', value);
+                            if ('ne' === operator) return eb(dbField, '<>', value);
+                            if ('gt' === operator) return eb(dbField, '>', value);
+                            if ('gte' === operator) return eb(dbField, '>=', value);
+                            if ('lt' === operator) return eb(dbField, '<', value);
+                            if ('lte' === operator) return eb(dbField, '<=', value);
+                            return eb(dbField, operator, value);
+                        };
+                        if ('OR' === connector) conditions.or.push(expr);
+                        else conditions.and.push(expr);
+                    }
+                    return {
+                        and: conditions.and.length ? conditions.and : null,
+                        or: conditions.or.length ? conditions.or : null
+                    };
+                },
+                async withReturning (values, builder, model, where) {
+                    let res = null;
+                    if (config?.type === 'mysql') {
+                        await builder.execute();
+                        const whereCondition = where[0];
+                        const field = values.id ? 'id' : whereCondition?.field ?? 'id';
+                        const value = values[field] ?? whereCondition?.value;
+                        const fieldString = getField(model, field);
+                        res = await db.selectFrom(getEntityName(model)).selectAll().where((eb)=>eb(fieldString, '=', value)).executeTakeFirst();
+                        return res;
+                    }
+                    if (config?.type === 'mssql') {
+                        res = await builder.outputAll('inserted').executeTakeFirst();
+                        return res;
+                    }
+                    res = await builder.returningAll().executeTakeFirst();
+                    return res;
+                },
+                getEntityName,
+                getField
+            };
+        };
+        const kysely_adapter_kyselyAdapter = (db, config)=>(opts)=>{
+                const { transformInput, withReturning, transformOutput, convertWhereClause, getEntityName, getField } = createEntityTransformer(db, opts, config);
+                return {
+                    id: 'kysely',
+                    async create (data) {
+                        const { model, data: values, select } = data;
+                        const transformed = transformInput(values, model, 'create');
+                        const tableName = getEntityName(model);
+                        const builder = db.insertInto(tableName).values(transformed);
+                        const result = await withReturning(transformed, builder, model, []);
+                        const output = transformOutput(result, model, select);
+                        return output;
+                    },
+                    async findOne (data) {
+                        const { model, where, select } = data;
+                        const whereArray = Array.isArray(where) ? where : [
+                            where
+                        ];
+                        const { and, or } = convertWhereClause(model, whereArray);
+                        const tableName = getEntityName(model);
+                        let query = db.selectFrom(tableName).selectAll();
+                        if (and) query = query.where((eb)=>{
+                            const conditions = and.map((expr)=>expr(eb));
+                            return eb.and(conditions);
+                        });
+                        if (or) query = query.where((eb)=>{
+                            const conditions = or.map((expr)=>expr(eb));
+                            return eb.or(conditions);
+                        });
+                        const res = await query.executeTakeFirst();
+                        if (!res) return null;
+                        return transformOutput(res, model, select);
+                    },
+                    async findMany (data) {
+                        const { model, where, limit, offset, sortBy } = data;
+                        const whereArray = where ? Array.isArray(where) ? where : [
+                            where
+                        ] : void 0;
+                        const { and, or } = convertWhereClause(model, whereArray);
+                        const tableName = getEntityName(model);
+                        let query = db.selectFrom(tableName);
+                        if (and) query = query.where((eb)=>{
+                            const conditions = and.map((expr)=>expr(eb));
+                            return eb.and(conditions);
+                        });
+                        if (or) query = query.where((eb)=>{
+                            const conditions = or.map((expr)=>expr(eb));
+                            return eb.or(conditions);
+                        });
+                        if (config?.type === 'mssql') {
+                            if (!offset) query = query.top(limit || 100);
+                        } else query = query.limit(limit || 100);
+                        if (sortBy) {
+                            const sortFieldString = getField(model, sortBy.field);
+                            query = query.orderBy(sortFieldString, sortBy.direction);
+                        }
+                        if (offset) {
+                            if (config?.type === 'mssql') {
+                                if (!sortBy) query = query.orderBy('id');
+                                query = query.offset(offset).fetch(limit || 100);
+                            } else query = query.offset(offset);
+                        }
+                        const res = await query.selectAll().execute();
+                        if (!res) return [];
+                        return res.map((r)=>transformOutput(r, model));
+                    },
+                    async update (data) {
+                        const { model, where, update: values } = data;
+                        const whereArray = Array.isArray(where) ? where : [
+                            where
+                        ];
+                        const { and, or } = convertWhereClause(model, whereArray);
+                        const transformedData = transformInput(values, model, 'update');
+                        const tableName = getEntityName(model);
+                        let query = db.updateTable(tableName).set(transformedData);
+                        if (and) query = query.where((eb)=>{
+                            const conditions = and.map((expr)=>expr(eb));
+                            return eb.and(conditions);
+                        });
+                        if (or) query = query.where((eb)=>{
+                            const conditions = or.map((expr)=>expr(eb));
+                            return eb.or(conditions);
+                        });
+                        const result = await withReturning(transformedData, query, model, whereArray);
+                        return transformOutput(result, model);
+                    },
+                    async updateMany (data) {
+                        const { model, where, update: values } = data;
+                        const whereArray = Array.isArray(where) ? where : [
+                            where
+                        ];
+                        const { and, or } = convertWhereClause(model, whereArray);
+                        const transformedData = transformInput(values, model, 'update');
+                        const tableName = getEntityName(model);
+                        let query = db.updateTable(tableName).set(transformedData);
+                        if (and) query = query.where((eb)=>{
+                            const conditions = and.map((expr)=>expr(eb));
+                            return eb.and(conditions);
+                        });
+                        if (or) query = query.where((eb)=>{
+                            const conditions = or.map((expr)=>expr(eb));
+                            return eb.or(conditions);
+                        });
+                        await query.execute();
+                        let selectQuery = db.selectFrom(tableName).selectAll();
+                        if (and) selectQuery = selectQuery.where((eb)=>{
+                            const conditions = and.map((expr)=>expr(eb));
+                            return eb.and(conditions);
+                        });
+                        if (or) selectQuery = selectQuery.where((eb)=>{
+                            const conditions = or.map((expr)=>expr(eb));
+                            return eb.or(conditions);
+                        });
+                        const fetchedResults = await selectQuery.execute();
+                        if (!fetchedResults || 0 === fetchedResults.length) return [];
+                        return fetchedResults.map((record)=>transformOutput(record, model));
+                    },
+                    async count (data) {
+                        const { model, where } = data;
+                        const whereArray = where ? Array.isArray(where) ? where : [
+                            where
+                        ] : void 0;
+                        const { and, or } = convertWhereClause(model, whereArray);
+                        const tableName = getEntityName(model);
+                        let query = db.selectFrom(tableName).select((eb)=>eb.fn.count('id').as('count'));
+                        if (and) query = query.where((eb)=>{
+                            const conditions = and.map((expr)=>expr(eb));
+                            return eb.and(conditions);
+                        });
+                        if (or) query = query.where((eb)=>{
+                            const conditions = or.map((expr)=>expr(eb));
+                            return eb.or(conditions);
+                        });
+                        const res = await query.execute();
+                        const count = res[0]?.count;
+                        return 'number' == typeof count ? count : 0;
+                    },
+                    async delete (data) {
+                        const { model, where } = data;
+                        const whereArray = Array.isArray(where) ? where : [
+                            where
+                        ];
+                        const { and, or } = convertWhereClause(model, whereArray);
+                        const tableName = getEntityName(model);
+                        let query = db.deleteFrom(tableName);
+                        if (and) query = query.where((eb)=>{
+                            const conditions = and.map((expr)=>expr(eb));
+                            return eb.and(conditions);
+                        });
+                        if (or) query = query.where((eb)=>{
+                            const conditions = or.map((expr)=>expr(eb));
+                            return eb.or(conditions);
+                        });
+                        await query.execute();
+                    },
+                    async deleteMany (data) {
+                        const { model, where } = data;
+                        const whereArray = Array.isArray(where) ? where : [
+                            where
+                        ];
+                        const { and, or } = convertWhereClause(model, whereArray);
+                        const tableName = getEntityName(model);
+                        let query = db.deleteFrom(tableName);
+                        if (and) query = query.where((eb)=>{
+                            const conditions = and.map((expr)=>expr(eb));
+                            return eb.and(conditions);
+                        });
+                        if (or) query = query.where((eb)=>{
+                            const conditions = or.map((expr)=>expr(eb));
+                            return eb.or(conditions);
+                        });
+                        const result = await query.execute();
+                        const count = result.length;
+                        return count;
+                    },
+                    async transaction (data) {
+                        const { callback } = data;
+                        if (opts.advanced?.disableTransactions) {
+                            const regularAdapter = kysely_adapter_kyselyAdapter(db, config)(opts);
+                            return await callback(regularAdapter);
+                        }
+                        try {
+                            return await db.transaction().execute(async (trx)=>{
+                                const transactionAdapter = kysely_adapter_kyselyAdapter(trx, config)(opts);
+                                return await callback(transactionAdapter);
+                            });
+                        } catch (error) {
+                            if (error instanceof Error && (error.message.includes('transactions are not supported') || error.message.toLowerCase().includes('no transaction support'))) {
+                                console.warn("Warning: Database transaction failed. If your database does not support transactions, you can disable this warning by setting opts.advanced.disableTransactions to true.");
+                                const regularAdapter = kysely_adapter_kyselyAdapter(db, config)(opts);
+                                return await callback(regularAdapter);
+                            }
+                            throw error;
+                        }
+                    },
+                    options: config
+                };
+            };
+        const memory_adapter_createEntityTransformer = (options)=>{
+            const schema = definition_getConsentTables(options);
+            function getField(model, field) {
+                if ('id' === field) return field;
+                const modelFields = schema[model]?.fields;
+                const f = modelFields ? modelFields[field] : void 0;
+                return f?.fieldName || field;
+            }
+            return {
+                transformInput (data, model, action) {
+                    const transformedData = 'update' === action ? {} : {
+                        id: options.advanced?.generateId ? options.advanced.generateId({
+                            model
+                        }) : data.id || generateId(schema[model].entityPrefix)
+                    };
+                    const fields = schema[model].fields;
+                    for(const field in fields)if (Object.hasOwn(fields, field)) {
+                        const value = data[field];
+                        const fieldInfo = fields[field];
+                        if (void 0 === value && !fieldInfo?.defaultValue) continue;
+                        const fieldName = fieldInfo?.fieldName || field;
+                        transformedData[fieldName] = applyDefaultValue(value, fieldInfo, action);
+                    }
+                    return transformedData;
+                },
+                transformOutput (data, model, select = []) {
+                    if (!data) return null;
+                    const transformedData = {};
+                    const hasId = data.id || data._id;
+                    if (hasId && (0 === select.length || select.includes('id'))) transformedData.id = data.id;
+                    const tableSchema = schema[model].fields;
+                    for(const key in tableSchema){
+                        if (select.length && !select.includes(key)) continue;
+                        const field = tableSchema[key];
+                        if (field) transformedData[key] = data[field.fieldName || key];
+                    }
+                    return transformedData;
+                },
+                convertWhereClause (where, table, model) {
+                    return table.filter((record)=>where.every((clause)=>{
+                            const { field: _field, value, operator = '=' } = clause;
+                            const field = getField(model, _field);
+                            if ('in' === operator) {
+                                if (!Array.isArray(value)) throw new Error('Value must be an array');
+                                return value.includes(record[field]);
+                            }
+                            if ('contains' === operator) {
+                                const fieldValue = record[field];
+                                return 'string' == typeof fieldValue && fieldValue.includes(value);
+                            }
+                            if ('starts_with' === operator) {
+                                const fieldValue = record[field];
+                                return 'string' == typeof fieldValue && fieldValue.startsWith(value);
+                            }
+                            if ('ends_with' === operator) {
+                                const fieldValue = record[field];
+                                return 'string' == typeof fieldValue && fieldValue.endsWith(value);
+                            }
+                            if ('eq' === operator) return record[field] === value;
+                            if ('ne' === operator) return record[field] !== value;
+                            return record[field] === value;
+                        }));
+                },
+                getField
+            };
+        };
+        const memory_adapter_memoryAdapter = (db)=>(options)=>{
+                const { transformInput, transformOutput, convertWhereClause, getField } = memory_adapter_createEntityTransformer(options);
+                return {
+                    id: 'memory',
+                    async create (data) {
+                        const { model, data: values, select } = data;
+                        const transformed = transformInput(values, model, 'create');
+                        if (!db[model]) db[model] = [];
+                        db[model].push(transformed);
+                        return transformOutput(transformed, model, select);
+                    },
+                    async findOne (data) {
+                        const { model, where, select } = data;
+                        const table = db[model] || [];
+                        const whereArray = Array.isArray(where) ? where : [
+                            where
+                        ];
+                        const res = convertWhereClause(whereArray, table, model);
+                        const record = res[0] || null;
+                        return transformOutput(record, model, select);
+                    },
+                    async findMany (data) {
+                        const { model, where, sortBy, limit, offset } = data;
+                        let table = db[model] || [];
+                        if (where) {
+                            const whereArray = Array.isArray(where) ? where : [
+                                where
+                            ];
+                            table = convertWhereClause(whereArray, table, model);
+                        }
+                        if (sortBy) {
+                            const field = getField(model, sortBy.field);
+                            table = [
+                                ...table
+                            ].sort((a, b)=>{
+                                if ('asc' === sortBy.direction) return a[field] > b[field] ? 1 : -1;
+                                return a[field] < b[field] ? 1 : -1;
+                            });
+                        }
+                        let result = table;
+                        if (void 0 !== offset) result = result.slice(offset);
+                        if (void 0 !== limit) result = result.slice(0, limit);
+                        return result.map((record)=>transformOutput(record, model));
+                    },
+                    async count (data) {
+                        const { model, where } = data;
+                        const table = db[model] || [];
+                        if (!where) return table.length;
+                        const whereArray = Array.isArray(where) ? where : [
+                            where
+                        ];
+                        const filtered = convertWhereClause(whereArray, table, model);
+                        return filtered.length;
+                    },
+                    async update (data) {
+                        const { model, where, update: values } = data;
+                        const table = db[model] || [];
+                        const whereArray = Array.isArray(where) ? where : [
+                            where
+                        ];
+                        const res = convertWhereClause(whereArray, table, model);
+                        for (const record of res)Object.assign(record, transformInput(values, model, 'update'));
+                        return transformOutput(res[0] || null, model);
+                    },
+                    async updateMany (data) {
+                        const { model, where, update: values } = data;
+                        const table = db[model] || [];
+                        const whereArray = Array.isArray(where) ? where : [
+                            where
+                        ];
+                        const res = convertWhereClause(whereArray, table, model);
+                        for (const record of res)Object.assign(record, transformInput(values, model, 'update'));
+                        return res.map((record)=>transformOutput(record, model));
+                    },
+                    async delete (data) {
+                        const { model, where } = data;
+                        const table = db[model] || [];
+                        const whereArray = Array.isArray(where) ? where : [
+                            where
+                        ];
+                        const res = convertWhereClause(whereArray, table, model);
+                        db[model] = table.filter((record)=>!res.includes(record));
+                    },
+                    async deleteMany (data) {
+                        const { model, where } = data;
+                        const table = db[model] || [];
+                        const whereArray = Array.isArray(where) ? where : [
+                            where
+                        ];
+                        const res = convertWhereClause(whereArray, table, model);
+                        let count = 0;
+                        db[model] = table.filter((record)=>{
+                            if (res.includes(record)) {
+                                count++;
+                                return false;
+                            }
+                            return true;
+                        });
+                        return count;
+                    },
+                    async transaction (data) {
+                        const { callback } = data;
+                        const tempDb = {};
+                        for(const key in db)if (Object.hasOwn(db, key)) tempDb[key] = JSON.parse(JSON.stringify(db[key]));
+                        const transactionAdapter = memory_adapter_memoryAdapter(tempDb)(options);
+                        const result = await callback(transactionAdapter);
+                        for(const key in tempDb)if (Object.hasOwn(tempDb, key)) db[key] = tempDb[key];
+                        return result;
+                    }
+                };
+            };
+        const createRegistry = (ctx)=>({
+                ...auditLogRegistry(ctx),
+                ...consentRegistry(ctx),
+                ...domainRegistry(ctx),
+                ...geoLocationRegistry(ctx),
+                ...consentGeoLocationRegistry(ctx),
+                ...consentPurposeJunctionRegistry(ctx),
+                ...consentPurposeRegistry(ctx),
+                ...policyRegistry(ctx),
+                ...consentRecordRegistry(ctx),
+                ...subjectRegistry(ctx),
+                ...consentWithdrawalRegistry(ctx)
+            });
+        var utils = __webpack_require__("./src/utils/index.ts");
+        async function utils_getAdapter(options) {
+            if (!options.database) {
+                const tables = definition_getConsentTables(options);
+                const memoryDB = Object.keys(tables).reduce((acc, key)=>{
+                    acc[key] = [];
+                    return acc;
+                }, {});
+                utils.kg.warn('No database configuration provided. Using memory adapter in development');
+                return memory_adapter_memoryAdapter(memoryDB)(options);
+            }
+            if ('function' == typeof options.database) return options.database(options);
+            const { kysely, databaseType } = await dialect_createKyselyAdapter(options);
+            if (!kysely) throw new src_error.kO('Failed to initialize database adapter', {
+                code: src_error.H8.INTERNAL_SERVER_ERROR,
+                status: 500
+            });
+            return kysely_adapter_kyselyAdapter(kysely, {
+                type: databaseType || 'sqlite'
+            })(options);
+        }
+        var results = __webpack_require__("./src/error/results.ts");
+        const fromC15TPromise = (promise)=>(0, src_error.p4)(promise, (error)=>({
+                    message: error instanceof Error ? error.message : String(error),
+                    code: src_error.H8.UNKNOWN_ERROR,
+                    name: 'C15TError',
+                    data: {
+                        error
+                    }
+                }));
+        const DEFAULT_SECRET = 'c15t-default-secret-please-change-in-production';
+        const init = async (options)=>{
+            try {
+                const adapterResult = await fromC15TPromise(utils_getAdapter(options));
+                return adapterResult.andThen((adapter)=>{
+                    const logger = (0, utils.hu)(options.logger);
+                    const baseURL = (0, utils.BS)(options.baseURL, options.basePath);
+                    const secret = options.secret || utils.OB.C15T_SECRET || utils.OB.CONSENT_SECRET || DEFAULT_SECRET;
+                    if (secret === DEFAULT_SECRET && utils.yv) logger.error('Using default secret in production. Set C15T_SECRET or pass secret in config.');
+                    const finalOptions = {
+                        ...options,
+                        secret,
+                        baseURL: baseURL ? new URL(baseURL).origin : '',
+                        basePath: options.basePath || '/api/c15t',
+                        plugins: [
+                            ...options.plugins || [],
+                            ...getInternalPlugins(options)
+                        ]
+                    };
+                    const generateIdFunc = ({ model, size = 16 })=>finalOptions?.advanced?.generateId?.({
+                            model,
+                            size
+                        }) || generateId(definition_getConsentTables(finalOptions)[model].entityPrefix);
+                    const registryContext = {
+                        adapter,
+                        options: finalOptions,
+                        logger,
+                        hooks: options.databaseHooks || [],
+                        generateId: generateIdFunc
+                    };
+                    const ctx = {
+                        appName: finalOptions.appName || 'c15t Consent Manager',
+                        options: finalOptions,
+                        trustedOrigins: getTrustedOrigins(finalOptions),
+                        baseURL: baseURL || '',
+                        secret,
+                        logger,
+                        generateId: generateIdFunc,
+                        adapter,
+                        registry: createRegistry(registryContext),
+                        tables: definition_getConsentTables(options)
+                    };
+                    return runPluginInit(ctx);
+                });
+            } catch (error) {
+                return (0, src_error.N5)(`Failed to initialize consent system: ${error instanceof Error ? error.message : String(error)}`, {
+                    code: src_error.H8.INITIALIZATION_FAILED,
+                    data: {
+                        error
+                    }
+                });
+            }
+        };
+        function runPluginInit(ctx) {
+            try {
+                let options = ctx.options;
+                const plugins = options.plugins || [];
+                let context = ctx;
+                for (const plugin of plugins)if (plugin.init) {
+                    const result = plugin.init(ctx);
+                    if ('object' == typeof result) {
+                        if (result.options) options = (0, external_defu_namespaceObject.defu)(result.options, options);
+                        if (result.context) context = {
+                            ...context,
+                            ...result.context
+                        };
+                    }
+                }
+                context.options = options;
+                return (0, results.ok)(context);
+            } catch (error) {
+                return (0, results.bG)(`Plugin initialization failed: ${error instanceof Error ? error.message : String(error)}`, {
+                    code: src_error.H8.PLUGIN_INITIALIZATION_FAILED,
+                    data: {
+                        error
+                    }
+                });
+            }
+        }
+        function getInternalPlugins(_options) {
+            const plugins = [];
+            return plugins;
+        }
+        function getTrustedOrigins(options) {
+            const baseURL = (0, utils.BS)(options.baseURL, options.basePath);
+            if (!baseURL) return [];
+            const trustedOrigins = [
+                new URL(baseURL).origin
+            ];
+            if (options.trustedOrigins && Array.isArray(options.trustedOrigins)) trustedOrigins.push(...options.trustedOrigins);
+            const envTrustedOrigins = utils.OB.C15T_TRUSTED_ORIGINS;
+            if (envTrustedOrigins) trustedOrigins.push(...envTrustedOrigins.split(','));
+            return trustedOrigins;
+        }
+        const c15tInstance = (options)=>{
+            const contextPromise = init(options);
+            const handler = async (request)=>{
+                const contextResult = await contextPromise;
+                return contextResult.asyncAndThen((ctx)=>{
+                    const basePath = ctx.options.basePath || '/api/c15t';
+                    const url = new URL(request.url);
+                    if (ctx.options.baseURL) {
+                        const baseURL = new URL(ctx.options.baseURL);
+                        if (!baseURL.pathname || '/' === baseURL.pathname) {
+                            ctx.options.baseURL = `${baseURL.origin}${basePath}`;
+                            ctx.baseURL = ctx.options.baseURL;
+                        }
+                    } else {
+                        const baseURL = (0, utils.BS)(void 0, basePath) || `${url.origin}${basePath}`;
+                        ctx.options.baseURL = baseURL;
+                        ctx.baseURL = baseURL;
+                    }
+                    let originsFromOptions = [];
+                    if (options.trustedOrigins) originsFromOptions = Array.isArray(options.trustedOrigins) ? options.trustedOrigins : options.trustedOrigins(request);
+                    ctx.trustedOrigins = [
+                        ...originsFromOptions,
+                        ctx.options.baseURL || '',
+                        url.origin
+                    ];
+                    try {
+                        const { handler } = router(ctx, options);
+                        return (0, src_error.i0)(handler(request), src_error.H8.REQUEST_HANDLER_ERROR);
+                    } catch (error) {
+                        const safeErrorMessage = error instanceof Error ? error.message.split('\n')[0] : 'An unknown error occurred';
+                        return (0, src_error.N5)(`Error processing request: ${safeErrorMessage}`, {
+                            code: src_error.H8.REQUEST_HANDLER_ERROR,
+                            status: 500,
+                            data: {
+                                url: request.url
+                            }
+                        });
+                    }
+                });
+            };
+            const getApi = async ()=>{
+                const contextResult = await contextPromise;
+                return contextResult.asyncAndThen((context)=>{
+                    if (!context.baseURL) try {
+                        const basePath = context.options.basePath || '/api/c15t';
+                        const baseURL = (0, utils.BS)(context.options.baseURL, basePath);
+                        if (baseURL) context.baseURL = baseURL;
+                    } catch (error) {
+                        return (0, src_error.N5)(`Failed to determine base URL: ${error instanceof Error ? error.message : String(error)}`, {
+                            code: src_error.H8.API_RETRIEVAL_ERROR
+                        });
+                    }
+                    try {
+                        const { endpoints } = router(context, options);
+                        const typedEndpoints = endpoints;
+                        return (0, src_error.Z2)(typedEndpoints);
+                    } catch (error) {
+                        return (0, src_error.N5)(`Failed to get API endpoints: ${error instanceof Error ? error.message : String(error)}`, {
+                            code: src_error.H8.API_RETRIEVAL_ERROR,
+                            data: {
+                                error
+                            }
+                        });
+                    }
+                });
+            };
+            return {
+                handler,
+                getApi,
+                options,
+                $context: contextPromise
+            };
+        };
+    },
+    "./src/error/codes.ts": function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+        "use strict";
+        __webpack_require__.d(__webpack_exports__, {
+            H: ()=>BASE_ERROR_CODES,
+            x: ()=>ERROR_CATEGORIES
+        });
+        const BASE_ERROR_CODES = {
+            NOT_FOUND: 'Resource not found',
+            BAD_REQUEST: 'Bad request',
+            CONFLICT: 'Conflict with current state',
+            CONSENT_NOT_FOUND: 'Consent not found',
+            CONSENT_EXPIRED: 'Consent has expired',
+            FAILED_TO_CREATE_CONSENT: 'Failed to create consent',
+            FAILED_TO_UPDATE_CONSENT: 'Failed to update consent',
+            FAILED_TO_GET_CONSENT: 'Failed to get consent',
+            FAILED_TO_CREATE_PURPOSE: 'Failed to create consentPurpose',
+            PURPOSE_NOT_FOUND: 'Consent Purpose not found',
+            INVALID_CONFIGURATION: 'Invalid configuration',
+            MISSING_REQUIRED_PARAMETER: 'Missing required parameter',
+            UNAUTHORIZED: 'Unauthorized',
+            FORBIDDEN: 'Forbidden',
+            INTERNAL_SERVER_ERROR: 'Internal server error',
+            INITIALIZATION_FAILED: 'Initialization failed',
+            PLUGIN_INITIALIZATION_FAILED: 'Plugin initialization failed',
+            DATABASE_CONNECTION_ERROR: 'Database connection error',
+            DATABASE_QUERY_ERROR: 'Database query error',
+            REQUEST_HANDLER_ERROR: 'Request handler error',
+            API_RETRIEVAL_ERROR: 'API retrieval error',
+            INVALID_REQUEST: 'Invalid request',
+            UNKNOWN_ERROR: 'Unknown error'
+        };
+        const ERROR_CATEGORIES = {
+            VALIDATION: 'validation',
+            AUTHORIZATION: 'authorization',
+            STORAGE: 'storage',
+            NETWORK: 'network',
+            PLUGIN: 'plugin',
+            CONFIGURATION: 'configuration',
+            UNEXPECTED: 'unexpected'
+        };
+    },
+    "./src/error/error.ts": function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+        "use strict";
+        __webpack_require__.d(__webpack_exports__, {
+            k: ()=>C15TError
+        });
+        var _codes__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__("./src/error/codes.ts");
+        class C15TError extends Error {
+            code;
+            status;
+            data;
+            category;
+            constructor(message, options){
+                super(message);
+                this.name = 'C15TError';
+                if (options) {
+                    this.code = options.code;
+                    this.status = options.status;
+                    this.data = options.data;
+                    this.category = options.category;
+                }
+                Object.setPrototypeOf(this, C15TError.prototype);
+            }
+            static fromResponse(response, data) {
+                let message = `HTTP error ${response.status}`;
+                let code;
+                let errorData;
+                if (data && 'object' == typeof data && null !== data) {
+                    const errorObj = data;
+                    if ('string' == typeof errorObj.message) message = errorObj.message;
+                    if ('string' == typeof errorObj.code) {
+                        const isKnownCode = Object.values(_codes__WEBPACK_IMPORTED_MODULE_0__.H).includes(errorObj.code);
+                        if (isKnownCode) code = errorObj.code;
+                    }
+                    if ('object' == typeof errorObj.data && null !== errorObj.data) errorData = errorObj.data;
+                }
+                return new C15TError(message, {
+                    code,
+                    status: response.status,
+                    data: errorData
+                });
+            }
+            static isC15TError(error) {
+                return error instanceof C15TError;
+            }
+        }
+    },
+    "./src/error/index.ts": function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+        "use strict";
+        __webpack_require__.d(__webpack_exports__, {
+            H8: ()=>_codes__WEBPACK_IMPORTED_MODULE_0__.H,
+            N5: ()=>_results__WEBPACK_IMPORTED_MODULE_2__.N5,
+            Z2: ()=>neverthrow__WEBPACK_IMPORTED_MODULE_5__.okAsync,
+            i0: ()=>_results__WEBPACK_IMPORTED_MODULE_2__.i0,
+            kO: ()=>_error__WEBPACK_IMPORTED_MODULE_1__.k,
+            p4: ()=>neverthrow__WEBPACK_IMPORTED_MODULE_5__.fromPromise
+        });
+        var _codes__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__("./src/error/codes.ts");
+        var _error__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__("./src/error/error.ts");
+        var _results__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__("./src/error/results.ts");
+        __webpack_require__("./src/error/recovery.ts");
+        __webpack_require__("./src/error/pipeline.ts");
+        var neverthrow__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__("neverthrow");
+    },
+    "./src/error/pipeline.ts": function(__unused_webpack_module, __unused_webpack___webpack_exports__, __webpack_require__) {
+        "use strict";
+        __webpack_require__("./src/error/results.ts");
+    },
+    "./src/error/recovery.ts": function(__unused_webpack_module, __unused_webpack___webpack_exports__, __webpack_require__) {
+        "use strict";
+        __webpack_require__("neverthrow");
+    },
+    "./src/error/results.ts": function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+        "use strict";
+        __webpack_require__.d(__webpack_exports__, {
+            N5: ()=>failAsync,
+            bG: ()=>fail,
+            i0: ()=>safeResultAsync,
+            ok: ()=>ok
+        });
+        var neverthrow__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__("neverthrow");
+        var _codes__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__("./src/error/codes.ts");
+        var _error__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__("./src/error/error.ts");
+        const ok = (value)=>(0, neverthrow__WEBPACK_IMPORTED_MODULE_0__.ok)(value);
+        const fail = (message, options)=>(0, neverthrow__WEBPACK_IMPORTED_MODULE_0__.err)(new _error__WEBPACK_IMPORTED_MODULE_1__.k(message, options));
+        const failAsync = (message, options)=>neverthrow__WEBPACK_IMPORTED_MODULE_0__.ResultAsync.fromSafePromise(Promise.reject(new _error__WEBPACK_IMPORTED_MODULE_1__.k(message, options)));
+        const safeResultAsync = (promise, errorCode = _codes__WEBPACK_IMPORTED_MODULE_2__.H.UNKNOWN_ERROR)=>neverthrow__WEBPACK_IMPORTED_MODULE_0__.ResultAsync.fromPromise(promise, (error)=>new _error__WEBPACK_IMPORTED_MODULE_1__.k(error instanceof Error ? error.message : String(error), {
+                    code: errorCode,
+                    data: {
+                        originalError: error
+                    }
+                }));
+    },
+    "./src/plugins/geo/index.ts": function() {},
+    "./src/types/index.ts": function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+        "use strict";
+        __webpack_require__.r(__webpack_exports__);
+    },
+    "./src/utils/env.ts": function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+        "use strict";
+        __webpack_require__.d(__webpack_exports__, {
+            OB: ()=>env,
+            Y8: ()=>isTest,
+            aD: ()=>nodeENV,
+            yG: ()=>isDevelopment,
+            yv: ()=>isProduction
+        });
+        const env = 'undefined' != typeof process ? process.env : {};
+        const isProduction = 'undefined' != typeof process && 'production' === process.env.NODE_ENV;
+        const isDevelopment = 'undefined' != typeof process && 'development' === process.env.NODE_ENV;
+        function toBoolean(val) {
+            return val ? 'false' !== val : false;
+        }
+        const nodeENV = 'undefined' != typeof process && process.env && process.env.NODE_ENV || '';
+        const isTest = 'test' === nodeENV || toBoolean(env.TEST);
+    },
+    "./src/utils/hide-metadata.ts": function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+        "use strict";
+        __webpack_require__.d(__webpack_exports__, {
+            a: ()=>HIDE_METADATA
+        });
+        const HIDE_METADATA = {
+            isAction: false
+        };
+    },
+    "./src/utils/index.ts": function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+        "use strict";
+        __webpack_require__.d(__webpack_exports__, {
+            XF: ()=>url.XF,
+            BS: ()=>url.BS,
+            yG: ()=>env.yG,
+            Y8: ()=>env.Y8,
+            P$: ()=>url.P$,
+            eU: ()=>url.eU,
+            yv: ()=>env.yv,
+            OB: ()=>env.OB,
+            hu: ()=>logger.hu,
+            rC: ()=>stringifyJson,
+            Ev: ()=>url.Ev,
+            kg: ()=>logger.kg,
+            Mo: ()=>parseJson,
+            cN: ()=>logger.cN,
+            gr: ()=>logger.gr,
+            aD: ()=>env.aD,
+            ae: ()=>hide_metadata.a
+        });
+        var env = __webpack_require__("./src/utils/env.ts");
+        var hide_metadata = __webpack_require__("./src/utils/hide-metadata.ts");
+        var logger = __webpack_require__("./src/utils/logger.ts");
+        var url = __webpack_require__("./src/utils/url.ts");
+        var external_superjson_ = __webpack_require__("superjson");
+        var external_superjson_default = /*#__PURE__*/ __webpack_require__.n(external_superjson_);
+        function parseJson(json) {
+            return external_superjson_default().parse(json);
+        }
+        function stringifyJson(value) {
+            return external_superjson_default().stringify(value);
+        }
+    },
+    "./src/utils/logger.ts": function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+        "use strict";
+        __webpack_require__.d(__webpack_exports__, {
+            cN: ()=>shouldPublishLog,
+            gr: ()=>levels,
+            hu: ()=>createLogger,
+            kg: ()=>logger
+        });
+        const levels = [
+            'info',
+            'success',
+            'warn',
+            'error',
+            'debug'
+        ];
+        function shouldPublishLog(currentLogLevel, logLevel) {
+            return levels.indexOf(logLevel) <= levels.indexOf(currentLogLevel);
+        }
+        const colors = {
+            reset: '\x1b[0m',
+            bright: '\x1b[1m',
+            dim: '\x1b[2m',
+            underscore: '\x1b[4m',
+            blink: '\x1b[5m',
+            reverse: '\x1b[7m',
+            hidden: '\x1b[8m',
+            fg: {
+                black: '\x1b[30m',
+                red: '\x1b[31m',
+                green: '\x1b[32m',
+                yellow: '\x1b[33m',
+                blue: '\x1b[34m',
+                magenta: '\x1b[35m',
+                cyan: '\x1b[36m',
+                white: '\x1b[37m'
+            },
+            bg: {
+                black: '\x1b[40m',
+                red: '\x1b[41m',
+                green: '\x1b[42m',
+                yellow: '\x1b[43m',
+                blue: '\x1b[44m',
+                magenta: '\x1b[45m',
+                cyan: '\x1b[46m',
+                white: '\x1b[47m'
+            }
+        };
+        const levelColors = {
+            info: colors.fg.blue,
+            success: colors.fg.green,
+            warn: colors.fg.yellow,
+            error: colors.fg.red,
+            debug: colors.fg.magenta
+        };
+        const formatMessage = (level, message)=>{
+            const timestamp = new Date().toISOString();
+            return `${colors.dim}${timestamp}${colors.reset} ${levelColors[level]}${level.toUpperCase()}${colors.reset} ${colors.bright}[c15t]:${colors.reset} ${message}`;
+        };
+        const createLogger = (options)=>{
+            const enabled = options?.disabled !== true;
+            const logLevel = options?.level ?? 'error';
+            const LogFunc = (level, message, args = [])=>{
+                if (!enabled || !shouldPublishLog(logLevel, level)) return;
+                const formattedMessage = formatMessage(level, message);
+                if (!options || 'function' != typeof options.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;
+                }
+                options.log('success' === level ? 'info' : level, message, ...args);
+            };
+            return Object.fromEntries(levels.map((level)=>[
+                    level,
+                    (...[message, ...args])=>LogFunc(level, message, args)
+                ]));
+        };
+        const logger = createLogger();
+    },
+    "./src/utils/url.ts": function(__unused_webpack_module, __webpack_exports__, __webpack_require__) {
+        "use strict";
+        __webpack_require__.d(__webpack_exports__, {
+            BS: ()=>getBaseURL,
+            Ev: ()=>getProtocol,
+            P$: ()=>getOrigin,
+            XF: ()=>getHost,
+            eU: ()=>checkURLValidity
+        });
+        var _error__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__("./src/error/index.ts");
+        var _utils_env__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__("./src/utils/env.ts");
+        const TRAILING_SLASHES_REGEX = /\/+$/;
+        function checkHasPath(url) {
+            try {
+                const parsedUrl = new URL(url);
+                return '/' !== parsedUrl.pathname;
+            } catch  {
+                throw new _error__WEBPACK_IMPORTED_MODULE_0__.kO(`Invalid base URL: ${url}. Please provide a valid base URL.`, {
+                    code: _error__WEBPACK_IMPORTED_MODULE_0__.H8.BAD_REQUEST,
+                    status: 400,
+                    data: {
+                        url
+                    }
+                });
+            }
+        }
+        function withPath(url, path = '/api/auth') {
+            const hasPath = checkHasPath(url);
+            if (hasPath) return url;
+            const pathWithSlash = path.startsWith('/') ? path : `/${path}`;
+            return `${url.replace(TRAILING_SLASHES_REGEX, '')}${pathWithSlash}`;
+        }
+        function getBaseURL(url, path) {
+            if (url) return withPath(url, path);
+            const fromEnv = _utils_env__WEBPACK_IMPORTED_MODULE_1__.OB.C15T_URL || _utils_env__WEBPACK_IMPORTED_MODULE_1__.OB.NEXT_PUBLIC_C15T_URL || _utils_env__WEBPACK_IMPORTED_MODULE_1__.OB.PUBLIC_C15T_URL || _utils_env__WEBPACK_IMPORTED_MODULE_1__.OB.NUXT_PUBLIC_C15T_URL || _utils_env__WEBPACK_IMPORTED_MODULE_1__.OB.NUXT_PUBLIC_AUTH_URL || ('/' !== _utils_env__WEBPACK_IMPORTED_MODULE_1__.OB.BASE_URL ? _utils_env__WEBPACK_IMPORTED_MODULE_1__.OB.BASE_URL : void 0);
+            if (fromEnv) return withPath(fromEnv, path);
+            if ('undefined' != typeof window && window.location) return withPath(window.location.origin, path);
+        }
+        function getOrigin(url) {
+            try {
+                const parsedUrl = new URL(url);
+                return parsedUrl.origin;
+            } catch  {
+                return null;
+            }
+        }
+        function getProtocol(url) {
+            try {
+                const parsedUrl = new URL(url);
+                return parsedUrl.protocol;
+            } catch  {
+                return null;
+            }
+        }
+        const checkURLValidity = (url)=>{
+            const urlPattern = url.includes('://');
+            return urlPattern;
+        };
+        function getHost(url) {
+            if (url.includes('://')) {
+                const parsedUrl = new URL(url);
+                return parsedUrl.host;
+            }
+            return url;
+        }
+    },
+    neverthrow: function(module) {
+        "use strict";
+        module.exports = require("neverthrow");
+    },
+    superjson: function(module) {
+        "use strict";
+        module.exports = require("superjson");
+    }
+};
+var __webpack_module_cache__ = {};
+function __webpack_require__(moduleId) {
+    var cachedModule = __webpack_module_cache__[moduleId];
+    if (void 0 !== cachedModule) return cachedModule.exports;
+    var module = __webpack_module_cache__[moduleId] = {
+        exports: {}
+    };
+    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+    return module.exports;
+}
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = function(exports1) {
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+(()=>{
+    "use strict";
+    __webpack_require__.r(__webpack_exports__);
+    __webpack_require__.d(__webpack_exports__, {
+        BASE_ERROR_CODES: ()=>_error_codes__WEBPACK_IMPORTED_MODULE_1__.H,
+        ClientTypes: ()=>_client_types__WEBPACK_IMPORTED_MODULE_4__,
+        ERROR_CATEGORIES: ()=>_error_codes__WEBPACK_IMPORTED_MODULE_1__.x,
+        HIDE_METADATA: ()=>_utils__WEBPACK_IMPORTED_MODULE_2__.ae,
+        Types: ()=>_types__WEBPACK_IMPORTED_MODULE_6__,
+        c15tClient: ()=>_client__WEBPACK_IMPORTED_MODULE_3__.G,
+        c15tInstance: ()=>_core__WEBPACK_IMPORTED_MODULE_0__.w,
+        checkURLValidity: ()=>_utils__WEBPACK_IMPORTED_MODULE_2__.eU,
+        createConsentClient: ()=>_client__WEBPACK_IMPORTED_MODULE_3__.D,
+        createLogger: ()=>_utils__WEBPACK_IMPORTED_MODULE_2__.hu,
+        env: ()=>_utils__WEBPACK_IMPORTED_MODULE_2__.OB,
+        getBaseURL: ()=>_utils__WEBPACK_IMPORTED_MODULE_2__.BS,
+        getHost: ()=>_utils__WEBPACK_IMPORTED_MODULE_2__.XF,
+        getOrigin: ()=>_utils__WEBPACK_IMPORTED_MODULE_2__.P$,
+        getProtocol: ()=>_utils__WEBPACK_IMPORTED_MODULE_2__.Ev,
+        isDevelopment: ()=>_utils__WEBPACK_IMPORTED_MODULE_2__.yG,
+        isProduction: ()=>_utils__WEBPACK_IMPORTED_MODULE_2__.yv,
+        isTest: ()=>_utils__WEBPACK_IMPORTED_MODULE_2__.Y8,
+        levels: ()=>_utils__WEBPACK_IMPORTED_MODULE_2__.gr,
+        logger: ()=>_utils__WEBPACK_IMPORTED_MODULE_2__.kg,
+        nodeENV: ()=>_utils__WEBPACK_IMPORTED_MODULE_2__.aD,
+        parseJson: ()=>_utils__WEBPACK_IMPORTED_MODULE_2__.Mo,
+        shouldPublishLog: ()=>_utils__WEBPACK_IMPORTED_MODULE_2__.cN,
+        stringifyJson: ()=>_utils__WEBPACK_IMPORTED_MODULE_2__.rC
+    });
+    var _core__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__("./src/core.ts");
+    var _error_codes__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__("./src/error/codes.ts");
+    var _utils__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__("./src/utils/index.ts");
+    var _client__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__("./src/client/index.ts");
+    var _client_types__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__("./src/client/types.ts");
+    var _plugins_geo__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__("./src/plugins/geo/index.ts");
+    var __WEBPACK_REEXPORT_OBJECT__ = {};
+    for(var __WEBPACK_IMPORT_KEY__ in _plugins_geo__WEBPACK_IMPORTED_MODULE_5__)if ([
+        "HIDE_METADATA",
+        "env",
+        "createLogger",
+        "BASE_ERROR_CODES",
+        "ERROR_CATEGORIES",
+        "getHost",
+        "shouldPublishLog",
+        "getBaseURL",
+        "stringifyJson",
+        "isProduction",
+        "Types",
+        "default",
+        "nodeENV",
+        "ClientTypes",
+        "c15tInstance",
+        "isTest",
+        "checkURLValidity",
+        "levels",
+        "isDevelopment",
+        "logger",
+        "getOrigin",
+        "parseJson",
+        "c15tClient",
+        "createConsentClient",
+        "getProtocol"
+    ].indexOf(__WEBPACK_IMPORT_KEY__) < 0) __WEBPACK_REEXPORT_OBJECT__[__WEBPACK_IMPORT_KEY__] = (function(key) {
+        return _plugins_geo__WEBPACK_IMPORTED_MODULE_5__[key];
+    }).bind(0, __WEBPACK_IMPORT_KEY__);
+    __webpack_require__.d(__webpack_exports__, __WEBPACK_REEXPORT_OBJECT__);
+    var _types__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__("./src/types/index.ts");
+})();
+var __webpack_export_target__ = exports;
+for(var __webpack_i__ in __webpack_exports__)__webpack_export_target__[__webpack_i__] = __webpack_exports__[__webpack_i__];
+if (__webpack_exports__.__esModule) Object.defineProperty(__webpack_export_target__, '__esModule', {
+    value: true
+});