@c15t/backend 1.0.5 → 1.2.0-canary.0

package/dist/router.cjs

@@ -0,0 +1,1213 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ('undefined' != typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    router: ()=>router
+});
+const server_namespaceObject = require("@orpc/server");
+const contract_namespaceObject = require("@orpc/contract");
+const external_zod_namespaceObject = require("zod");
+const external_base_x_namespaceObject = require("base-x");
+var external_base_x_default = /*#__PURE__*/ __webpack_require__.n(external_base_x_namespaceObject);
+external_base_x_default()('123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz');
+const 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
+]);
+require("neverthrow");
+const error_codes_ERROR_CODES = Object.freeze({
+    NOT_FOUND: 'Resource not found',
+    BAD_REQUEST: 'Bad request',
+    CONFLICT: 'Conflict with current state',
+    MISSING_REQUIRED_PARAMETER: 'Missing required parameter',
+    UNAUTHORIZED: 'Unauthorized',
+    FORBIDDEN: 'Forbidden',
+    INTERNAL_SERVER_ERROR: 'Internal server error',
+    INITIALIZATION_FAILED: 'Initialization failed',
+    DATABASE_CONNECTION_ERROR: 'Database connection error',
+    DATABASE_QUERY_ERROR: 'Database query error',
+    INVALID_CONFIGURATION: 'Invalid configuration',
+    REQUEST_HANDLER_ERROR: 'Request handler error',
+    INVALID_REQUEST: 'Invalid request',
+    UNKNOWN_ERROR: 'Unknown error',
+    NETWORK_ERROR: 'Network error',
+    PLUGIN_INITIALIZATION_FAILED: 'Plugin initialization failed',
+    API_RETRIEVAL_ERROR: 'API retrieval error',
+    VALIDATION_ERROR: 'Validation error',
+    UNEXPECTED: 'Unexpected error'
+});
+const ERROR_CATEGORIES = Object.freeze({
+    VALIDATION: 'validation',
+    AUTHORIZATION: 'authorization',
+    STORAGE: 'storage',
+    NETWORK: 'network',
+    PLUGIN: 'plugin',
+    CONFIGURATION: 'configuration',
+    UNEXPECTED: 'unexpected'
+});
+const api_namespaceObject = require("@opentelemetry/api");
+api_namespaceObject.trace.getTracer('@doubletie/results');
+class error_class_DoubleTieError extends server_namespaceObject.ORPCError {
+    category;
+    meta;
+    statusCode;
+    constructor(message, options = {
+        code: error_codes_ERROR_CODES.UNKNOWN_ERROR,
+        status: 500,
+        category: ERROR_CATEGORIES.UNEXPECTED,
+        cause: void 0,
+        meta: {}
+    }){
+        super(options.code ?? error_codes_ERROR_CODES.UNKNOWN_ERROR, {
+            message,
+            cause: options.cause,
+            data: options.meta ?? {}
+        });
+        this.name = 'DoubleTieError';
+        this.category = options.category ?? ERROR_CATEGORIES.UNEXPECTED;
+        this.meta = options.meta ?? {};
+        this.statusCode = options.status ?? 500;
+        tracing_withSpan('create_doubletie_error', async (span)=>{
+            span.setAttributes({
+                'error.name': this.constructor.name,
+                'error.message': message,
+                'error.code': this.code,
+                'error.status': this.statusCode,
+                'error.category': this.category,
+                'error.has_cause': !!this.cause,
+                'error.cause_type': this.cause instanceof Error ? this.cause.constructor.name : typeof this.cause,
+                'error.has_meta': !!this.meta
+            });
+            if (this.cause instanceof Error) span.recordException(this.cause);
+        });
+        if (Error.captureStackTrace) Error.captureStackTrace(this, this.constructor);
+    }
+    static isDoubleTieError(error) {
+        return error instanceof error_class_DoubleTieError;
+    }
+    toJSON() {
+        const validationErrorMessage = this.meta?.validationErrors ? String(this.meta.validationErrors) : void 0;
+        const stackTrace = this.stack ? this.stack.split('\n').map((line)=>line.trim()).filter((line)=>line && !line.includes('Error: ')) : [];
+        return {
+            code: this.code,
+            message: validationErrorMessage || this.message,
+            status: this.statusCode,
+            defined: true,
+            data: {
+                category: this.category,
+                meta: this.meta,
+                ...'production' === process.env.NODE_ENV ? {} : {
+                    stack: stackTrace
+                },
+                ...validationErrorMessage && this.message ? {
+                    originalMessage: this.message
+                } : {},
+                ...this.cause ? {
+                    cause: this.cause instanceof Error ? {
+                        name: this.cause.name,
+                        message: this.cause.message,
+                        stack: this.cause.stack ? this.cause.stack.split('\n').map((line)=>line.trim()) : void 0
+                    } : this.cause
+                } : {}
+            }
+        };
+    }
+    static fromResponse(response, data) {
+        let message = `HTTP error ${response.status}`;
+        let errorCode = `HTTP ${response.status}`;
+        let errorMeta = {};
+        if (data && 'object' == typeof data && null !== data) {
+            const errorObj = data;
+            if ('string' == typeof errorObj.message) message = errorObj.message;
+            if ('string' == typeof errorObj.code) errorCode = errorObj.code;
+            if ('object' == typeof errorObj.data && null !== errorObj.data) errorMeta = errorObj.data;
+        }
+        return new error_class_DoubleTieError(message, {
+            code: errorCode,
+            status: response.status,
+            meta: errorMeta
+        });
+    }
+    withMeta(additionalMeta) {
+        return new error_class_DoubleTieError(this.message, {
+            code: this.code,
+            status: this.statusCode,
+            category: this.category,
+            cause: this.cause instanceof Error ? this.cause : void 0,
+            meta: {
+                ...this.meta,
+                ...additionalMeta
+            }
+        });
+    }
+    static createSubclass(name) {
+        const ErrorSubclass = class extends error_class_DoubleTieError {
+            constructor(message, options){
+                super(message, options);
+                Object.defineProperty(this, 'name', {
+                    value: name
+                });
+            }
+        };
+        Object.defineProperty(ErrorSubclass, 'name', {
+            value: name
+        });
+        return ErrorSubclass;
+    }
+    static formatValidationError(error) {
+        if (!error.meta) return error.message;
+        let formattedMessage = `${error.message} (${error.code})`;
+        if (error.meta.validationErrors) formattedMessage += `\nValidation Errors: ${JSON.stringify(error.meta.validationErrors, null, 2)}`;
+        const otherMeta = Object.fromEntries(Object.entries(error.meta).filter(([key])=>'validationErrors' !== key));
+        if (Object.keys(otherMeta).length > 0) formattedMessage += `\nAdditional Context: ${JSON.stringify(otherMeta, null, 2)}`;
+        return formattedMessage;
+    }
+}
+require("@doubletie/logger");
+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())
+});
+const PolicyTypeSchema = external_zod_namespaceObject.z["enum"]([
+    'cookie_banner',
+    'privacy_policy',
+    'dpa',
+    'terms_and_conditions',
+    'marketing_communications',
+    'age_verification',
+    'other'
+]);
+external_zod_namespaceObject.z.object({
+    id: external_zod_namespaceObject.z.string(),
+    version: external_zod_namespaceObject.z.string(),
+    type: PolicyTypeSchema,
+    name: external_zod_namespaceObject.z.string(),
+    effectiveDate: external_zod_namespaceObject.z.date(),
+    expirationDate: external_zod_namespaceObject.z.date().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())
+});
+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())
+});
+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())
+});
+external_zod_namespaceObject.z.object({
+    id: external_zod_namespaceObject.z.string(),
+    subjectId: external_zod_namespaceObject.z.string(),
+    domainId: external_zod_namespaceObject.z.string(),
+    purposeIds: external_zod_namespaceObject.z.array(external_zod_namespaceObject.z.string()),
+    metadata: external_zod_namespaceObject.z.record(external_zod_namespaceObject.z.unknown()).nullable().optional(),
+    policyId: external_zod_namespaceObject.z.string().optional(),
+    ipAddress: external_zod_namespaceObject.z.string().nullable().optional(),
+    userAgent: external_zod_namespaceObject.z.string().nullable().optional(),
+    status: external_zod_namespaceObject.z["enum"]([
+        'active',
+        'withdrawn',
+        'expired'
+    ]).default('active'),
+    withdrawalReason: external_zod_namespaceObject.z.string().nullable().optional(),
+    givenAt: external_zod_namespaceObject.z.date().default(()=>new Date()),
+    validUntil: external_zod_namespaceObject.z.date().nullable().optional(),
+    isActive: external_zod_namespaceObject.z.boolean().default(true)
+});
+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())
+});
+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())
+});
+require("node:crypto");
+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().regex(/^(?:[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?\.)+[a-z]{2,}$/i, 'invalid domain'),
+    type: PolicyTypeSchema,
+    metadata: external_zod_namespaceObject.z.record(external_zod_namespaceObject.z.unknown()).optional()
+});
+const cookieBannerSchema = baseConsentSchema.extend({
+    type: external_zod_namespaceObject.z.literal('cookie_banner'),
+    preferences: external_zod_namespaceObject.z.record(external_zod_namespaceObject.z.boolean())
+});
+const policyBasedSchema = baseConsentSchema.extend({
+    type: external_zod_namespaceObject.z["enum"]([
+        'privacy_policy',
+        'dpa',
+        'terms_and_conditions'
+    ]),
+    policyId: external_zod_namespaceObject.z.string().optional(),
+    preferences: external_zod_namespaceObject.z.record(external_zod_namespaceObject.z.boolean()).optional()
+});
+const otherConsentSchema = baseConsentSchema.extend({
+    type: external_zod_namespaceObject.z["enum"]([
+        'marketing_communications',
+        'age_verification',
+        'other'
+    ]),
+    preferences: external_zod_namespaceObject.z.record(external_zod_namespaceObject.z.boolean()).optional()
+});
+const postConsentContract = contract_namespaceObject.oc.route({
+    method: 'POST',
+    path: '/consent/set',
+    description: `Records a user's consent preferences and creates necessary consent records.
+This endpoint handles various types of consent submissions:
+
+1. Cookie Banner Consent:
+   - Records granular cookie preferences
+   - Supports multiple consent purposes
+   - Creates audit trail for compliance
+
+2. Policy-Based Consent:
+   - Privacy Policy acceptance
+   - Data Processing Agreement (DPA) consent
+   - Terms and Conditions acceptance
+   - Links consent to specific policy versions
+
+3. Other Consent Types:
+   - Marketing communications preferences
+   - Age verification consent
+   - Custom consent types
+
+The endpoint performs the following operations:
+- Creates or retrieves subject records
+- Validates domain and policy information
+- Creates consent records with audit trails
+- Records consent purposes and preferences
+- Generates audit logs for compliance
+
+Use this endpoint to record user consent and maintain a compliant consent management system.`,
+    tags: [
+        'consent',
+        'cookie-banner'
+    ]
+}).errors({
+    INPUT_VALIDATION_FAILED: {
+        status: 422,
+        message: 'Invalid input parameters',
+        data: external_zod_namespaceObject.z.object({
+            formErrors: external_zod_namespaceObject.z.array(external_zod_namespaceObject.z.string()),
+            fieldErrors: external_zod_namespaceObject.z.record(external_zod_namespaceObject.z.string(), external_zod_namespaceObject.z.array(external_zod_namespaceObject.z.string()))
+        })
+    },
+    SUBJECT_CREATION_FAILED: {
+        status: 400,
+        message: 'Failed to create or find subject',
+        data: external_zod_namespaceObject.z.object({
+            subjectId: external_zod_namespaceObject.z.string().optional(),
+            externalSubjectId: external_zod_namespaceObject.z.string().optional()
+        })
+    },
+    DOMAIN_CREATION_FAILED: {
+        status: 500,
+        message: 'Failed to create or find domain',
+        data: external_zod_namespaceObject.z.object({
+            domain: external_zod_namespaceObject.z.string()
+        })
+    },
+    POLICY_NOT_FOUND: {
+        status: 404,
+        message: 'Policy not found',
+        data: external_zod_namespaceObject.z.object({
+            policyId: external_zod_namespaceObject.z.string(),
+            type: external_zod_namespaceObject.z.string()
+        })
+    },
+    POLICY_INACTIVE: {
+        status: 409,
+        message: 'Policy is not active',
+        data: external_zod_namespaceObject.z.object({
+            policyId: external_zod_namespaceObject.z.string(),
+            type: external_zod_namespaceObject.z.string()
+        })
+    },
+    POLICY_CREATION_FAILED: {
+        status: 500,
+        message: 'Failed to create or find policy',
+        data: external_zod_namespaceObject.z.object({
+            type: external_zod_namespaceObject.z.string()
+        })
+    },
+    PURPOSE_CREATION_FAILED: {
+        status: 500,
+        message: 'Failed to create consent purpose',
+        data: external_zod_namespaceObject.z.object({
+            purposeCode: external_zod_namespaceObject.z.string()
+        })
+    },
+    CONSENT_CREATION_FAILED: {
+        status: 500,
+        message: 'Failed to create consent record',
+        data: external_zod_namespaceObject.z.object({
+            subjectId: external_zod_namespaceObject.z.string(),
+            domain: external_zod_namespaceObject.z.string()
+        })
+    }
+}).input(external_zod_namespaceObject.z.discriminatedUnion('type', [
+    cookieBannerSchema,
+    policyBasedSchema,
+    otherConsentSchema
+])).output(external_zod_namespaceObject.z.object({
+    id: external_zod_namespaceObject.z.string(),
+    subjectId: external_zod_namespaceObject.z.string().optional(),
+    externalSubjectId: external_zod_namespaceObject.z.string().optional(),
+    domainId: external_zod_namespaceObject.z.string(),
+    domain: external_zod_namespaceObject.z.string(),
+    type: PolicyTypeSchema,
+    status: external_zod_namespaceObject.z.string(),
+    recordId: external_zod_namespaceObject.z.string(),
+    metadata: external_zod_namespaceObject.z.record(external_zod_namespaceObject.z.unknown()).optional(),
+    givenAt: external_zod_namespaceObject.z.date()
+}));
+const JurisdictionMessages = {
+    GDPR: 'GDPR or equivalent regulations require a cookie banner.',
+    CH: 'Switzerland requires similar data protection measures.',
+    BR: "Brazil's LGPD requires consent for cookies.",
+    PIPEDA: 'PIPEDA requires consent for data collection.',
+    AU: "Australia's Privacy Act mandates transparency about data collection.",
+    APPI: "Japan's APPI requires consent for data collection.",
+    PIPA: "South Korea's PIPA requires consent for data collection.",
+    NONE: 'No specific requirements'
+};
+const JurisdictionCodeSchema = external_zod_namespaceObject.z["enum"]([
+    'GDPR',
+    'CH',
+    'BR',
+    'PIPEDA',
+    'AU',
+    'APPI',
+    'PIPA',
+    'NONE'
+]);
+const JurisdictionInfoSchema = external_zod_namespaceObject.z.object({
+    code: JurisdictionCodeSchema,
+    message: external_zod_namespaceObject.z.string()
+});
+const showConsentBannerContract = contract_namespaceObject.oc.route({
+    method: 'GET',
+    path: '/show-consent-banner',
+    description: `Determines if a user should see a consent banner based on their location and applicable privacy regulations.
+This endpoint performs the following checks:
+
+1. Detects the user's location using various header information:
+   - Cloudflare country headers
+   - Vercel IP country headers
+   - AWS CloudFront headers
+   - Custom country code headers
+
+2. Determines the applicable jurisdiction based on the location:
+   - GDPR (EU/EEA/UK)
+   - Swiss Data Protection Act
+   - LGPD (Brazil)
+   - PIPEDA (Canada)
+   - Australian Privacy Principles
+   - APPI (Japan)
+   - PIPA (South Korea)
+
+3. Returns detailed information about:
+   - Whether to show the consent banner
+   - The applicable jurisdiction and its requirements
+   - The user's detected location (country and region)
+
+Use this endpoint to implement geo-targeted consent banners and ensure compliance with regional privacy regulations.`,
+    tags: [
+        'cookie-banner'
+    ]
+}).output(external_zod_namespaceObject.z.object({
+    showConsentBanner: external_zod_namespaceObject.z.boolean(),
+    jurisdiction: JurisdictionInfoSchema,
+    location: external_zod_namespaceObject.z.object({
+        countryCode: external_zod_namespaceObject.z.string().nullable(),
+        regionCode: external_zod_namespaceObject.z.string().nullable()
+    })
+}));
+const verifyConsentInputSchema = external_zod_namespaceObject.z.object({
+    subjectId: external_zod_namespaceObject.z.string().optional(),
+    externalSubjectId: external_zod_namespaceObject.z.string().optional(),
+    domain: external_zod_namespaceObject.z.string(),
+    type: PolicyTypeSchema,
+    policyId: external_zod_namespaceObject.z.string().optional(),
+    preferences: external_zod_namespaceObject.z.array(external_zod_namespaceObject.z.string()).optional()
+}).strict();
+const verify_contract_consentSchema = external_zod_namespaceObject.z.object({
+    id: external_zod_namespaceObject.z.string(),
+    purposeIds: external_zod_namespaceObject.z.array(external_zod_namespaceObject.z.string())
+}).passthrough();
+const verifyConsentContract = contract_namespaceObject.oc.route({
+    method: 'POST',
+    path: '/consent/verify',
+    description: `Verifies if a user has given valid consent for a specific policy and domain.
+This endpoint performs comprehensive consent verification by:
+
+1. Validating the subject's identity (using subjectId or externalSubjectId)
+2. Verifying the domain's existence and validity
+3. Checking if the specified policy exists and is active
+4. Validating that all required purposes have been consented to
+5. Ensuring the consent record is current and valid
+
+The endpoint supports different types of consent verification:
+- Cookie banner consent verification
+- Privacy policy consent verification
+- Terms and conditions verification
+- Marketing communications consent verification
+- Age verification
+- Custom consent types
+
+Use this endpoint to ensure compliance with privacy regulations and to verify user consent before processing personal data.`,
+    tags: [
+        'consent'
+    ]
+}).errors({
+    INPUT_VALIDATION_FAILED: {
+        status: 422,
+        message: 'Invalid input parameters',
+        data: external_zod_namespaceObject.z.object({
+            formErrors: external_zod_namespaceObject.z.array(external_zod_namespaceObject.z.string()),
+            fieldErrors: external_zod_namespaceObject.z.record(external_zod_namespaceObject.z.string(), external_zod_namespaceObject.z.array(external_zod_namespaceObject.z.string()).optional())
+        })
+    },
+    SUBJECT_NOT_FOUND: {
+        status: 404,
+        message: 'Subject not found',
+        data: external_zod_namespaceObject.z.object({
+            subjectId: external_zod_namespaceObject.z.string().optional(),
+            externalSubjectId: external_zod_namespaceObject.z.string().optional()
+        })
+    },
+    DOMAIN_NOT_FOUND: {
+        status: 404,
+        message: 'Domain not found',
+        data: external_zod_namespaceObject.z.object({
+            domain: external_zod_namespaceObject.z.string()
+        })
+    },
+    POLICY_NOT_FOUND: {
+        status: 404,
+        message: 'Policy not found or invalid',
+        data: external_zod_namespaceObject.z.object({
+            policyId: external_zod_namespaceObject.z.string(),
+            type: external_zod_namespaceObject.z.string()
+        })
+    },
+    PURPOSES_NOT_FOUND: {
+        status: 404,
+        message: 'Could not find all specified purposes',
+        data: external_zod_namespaceObject.z.object({
+            preferences: external_zod_namespaceObject.z.array(external_zod_namespaceObject.z.string()),
+            foundPurposes: external_zod_namespaceObject.z.array(external_zod_namespaceObject.z.string())
+        })
+    },
+    COOKIE_BANNER_PREFERENCES_REQUIRED: {
+        status: 400,
+        message: 'Preferences are required for cookie banner consent',
+        data: external_zod_namespaceObject.z.object({
+            type: external_zod_namespaceObject.z.literal('cookie_banner')
+        })
+    },
+    NO_CONSENT_FOUND: {
+        status: 404,
+        message: 'No consent found for the given policy',
+        data: external_zod_namespaceObject.z.object({
+            policyId: external_zod_namespaceObject.z.string(),
+            subjectId: external_zod_namespaceObject.z.string(),
+            domainId: external_zod_namespaceObject.z.string()
+        })
+    }
+}).input(verifyConsentInputSchema).output(external_zod_namespaceObject.z.object({
+    isValid: external_zod_namespaceObject.z.boolean(),
+    reasons: external_zod_namespaceObject.z.array(external_zod_namespaceObject.z.string()).optional(),
+    consent: verify_contract_consentSchema.optional()
+}));
+const consentContracts = {
+    post: postConsentContract,
+    showBanner: showConsentBannerContract,
+    verify: verifyConsentContract
+};
+const statusContract = contract_namespaceObject.oc.route({
+    method: 'GET',
+    path: '/status',
+    description: `Returns the current operational status and health metrics of the service.
+This endpoint provides real-time information about:
+- Overall service status (ok/error)
+- Current API version
+- Server timestamp
+- Storage system status and availability
+- Client information (IP, User Agent, Region)
+
+Use this endpoint for health checks, monitoring, and service status verification.`,
+    tags: [
+        'meta'
+    ]
+}).output(external_zod_namespaceObject.z.object({
+    status: external_zod_namespaceObject.z["enum"]([
+        'ok',
+        'error'
+    ]),
+    version: external_zod_namespaceObject.z.string(),
+    timestamp: external_zod_namespaceObject.z.date(),
+    storage: external_zod_namespaceObject.z.object({
+        type: external_zod_namespaceObject.z.string(),
+        available: external_zod_namespaceObject.z.boolean()
+    }),
+    client: external_zod_namespaceObject.z.object({
+        ip: external_zod_namespaceObject.z.string().nullable(),
+        userAgent: external_zod_namespaceObject.z.string().nullable(),
+        region: external_zod_namespaceObject.z.object({
+            countryCode: external_zod_namespaceObject.z.string().nullable(),
+            regionCode: external_zod_namespaceObject.z.string().nullable()
+        })
+    })
+}));
+const metaContracts = {
+    status: statusContract
+};
+const config = {
+    consent: consentContracts,
+    meta: metaContracts
+};
+const os = (0, server_namespaceObject.implement)(config);
+const postConsent = os.consent.post.handler(async ({ input, context })=>{
+    const typedContext = context;
+    const logger = typedContext.logger;
+    logger.info('Handling post-consent request');
+    const { type, subjectId, externalSubjectId, domain, metadata, preferences } = input;
+    logger.debug('Request parameters', {
+        type,
+        subjectId,
+        externalSubjectId,
+        domain
+    });
+    try {
+        const subject = await typedContext.registry.findOrCreateSubject({
+            subjectId,
+            externalSubjectId,
+            ipAddress: typedContext.ipAddress || 'unknown'
+        });
+        if (!subject) throw new server_namespaceObject.ORPCError('SUBJECT_CREATION_FAILED', {
+            data: {
+                subjectId,
+                externalSubjectId
+            }
+        });
+        logger.debug('Subject found/created', {
+            subjectId: subject.id
+        });
+        const domainRecord = await typedContext.registry.findOrCreateDomain(domain);
+        if (!domainRecord) throw new server_namespaceObject.ORPCError('DOMAIN_CREATION_FAILED', {
+            data: {
+                domain
+            }
+        });
+        const now = new Date();
+        let policyId;
+        let purposeIds = [];
+        if ('policyId' in input && input.policyId) {
+            policyId = input.policyId;
+            const policy = await typedContext.registry.findConsentPolicyById(policyId);
+            if (!policy) throw new server_namespaceObject.ORPCError('POLICY_NOT_FOUND', {
+                data: {
+                    policyId,
+                    type
+                }
+            });
+            if (!policy.isActive) throw new server_namespaceObject.ORPCError('POLICY_INACTIVE', {
+                data: {
+                    policyId,
+                    type
+                }
+            });
+        } else {
+            const policy = await typedContext.registry.findOrCreatePolicy(type);
+            if (!policy) throw new server_namespaceObject.ORPCError('POLICY_CREATION_FAILED', {
+                data: {
+                    type
+                }
+            });
+            policyId = policy.id;
+        }
+        if (preferences) {
+            const consentedPurposes = Object.entries(preferences).filter(([_, isConsented])=>isConsented).map(([purposeCode])=>purposeCode);
+            const existingPurposes = await Promise.all(consentedPurposes.map((purposeCode)=>typedContext.registry.findConsentPurposeByCode(purposeCode)));
+            const purposesToCreate = consentedPurposes.filter((_purposeCode, index)=>!existingPurposes[index]);
+            const createdPurposes = await Promise.all(purposesToCreate.map((purposeCode)=>typedContext.registry.createConsentPurpose({
+                    code: purposeCode,
+                    name: purposeCode,
+                    description: `Auto-created consentPurpose for ${purposeCode}`,
+                    isActive: true,
+                    isEssential: false,
+                    legalBasis: 'consent',
+                    createdAt: now,
+                    updatedAt: now
+                })));
+            purposeIds = [
+                ...existingPurposes.filter((p)=>null !== p).map((p)=>p.id),
+                ...createdPurposes.filter((p)=>null !== p).map((p)=>p.id)
+            ];
+            if (purposeIds.length !== consentedPurposes.length) throw new server_namespaceObject.ORPCError('PURPOSE_CREATION_FAILED', {
+                data: {
+                    purposeCode: purposesToCreate[purposeIds.length - consentedPurposes.length]
+                }
+            });
+        }
+        const result = await typedContext.adapter.transaction({
+            callback: async (tx)=>{
+                const consentRecord = await tx.create({
+                    model: 'consent',
+                    data: {
+                        subjectId: subject.id,
+                        domainId: domainRecord.id,
+                        policyId,
+                        purposeIds,
+                        status: 'active',
+                        isActive: true,
+                        givenAt: now,
+                        ipAddress: typedContext.ipAddress || 'unknown',
+                        agent: typedContext.userAgent || 'unknown',
+                        history: []
+                    }
+                });
+                const record = await tx.create({
+                    model: 'consentRecord',
+                    data: {
+                        subjectId: subject.id,
+                        consentId: consentRecord.id,
+                        actionType: 'consent_given',
+                        details: metadata,
+                        createdAt: now
+                    }
+                });
+                await tx.create({
+                    model: 'auditLog',
+                    data: {
+                        subjectId: subject.id,
+                        entityType: 'consent',
+                        entityId: consentRecord.id,
+                        actionType: 'consent_given',
+                        details: {
+                            consentId: consentRecord.id,
+                            type
+                        },
+                        timestamp: now,
+                        ipAddress: typedContext.ipAddress || 'unknown',
+                        agent: typedContext.userAgent || 'unknown'
+                    }
+                });
+                return {
+                    consent: consentRecord,
+                    record
+                };
+            }
+        });
+        if (!result || !result.consent || !result.record) throw new server_namespaceObject.ORPCError('CONSENT_CREATION_FAILED', {
+            data: {
+                subjectId: subject.id,
+                domain
+            }
+        });
+        return {
+            id: result.consent.id,
+            subjectId: subject.id,
+            externalSubjectId: subject.externalId ?? void 0,
+            domainId: domainRecord.id,
+            domain: domainRecord.name,
+            type,
+            status: result.consent.status,
+            recordId: result.record.id,
+            metadata,
+            givenAt: result.consent.givenAt
+        };
+    } catch (error) {
+        logger.error('Error in post-consent handler', {
+            error: error instanceof Error ? error.message : String(error),
+            errorType: error instanceof Error ? error.constructor.name : typeof error
+        });
+        if (error instanceof server_namespaceObject.ORPCError) throw error;
+        throw new server_namespaceObject.ORPCError('INTERNAL_SERVER_ERROR', {
+            message: error instanceof Error ? error.message : String(error)
+        });
+    }
+});
+const show_banner_handler_showConsentBanner = os.consent.showBanner.handler(({ context })=>{
+    const typedContext = context;
+    const headers = typedContext.headers;
+    if (!headers) throw new server_namespaceObject.ORPCError('LOCATION_DETECTION_FAILED', {
+        data: {
+            reason: 'No headers found in request context'
+        }
+    });
+    const normalizeHeader = (value)=>{
+        if (!value) return null;
+        return Array.isArray(value) ? value[0] ?? null : value;
+    };
+    const countryCode = normalizeHeader(headers.get('cf-ipcountry')) ?? normalizeHeader(headers.get('x-vercel-ip-country')) ?? normalizeHeader(headers.get('x-amz-cf-ipcountry')) ?? normalizeHeader(headers.get('x-country-code'));
+    const regionCode = normalizeHeader(headers.get('x-vercel-ip-country-region')) ?? normalizeHeader(headers.get('x-region-code'));
+    const { showConsentBanner, jurisdictionCode, message } = checkJurisdiction(countryCode);
+    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';
+    if (countryCode) {
+        const jurisdictionMap = [
+            {
+                sets: [
+                    jurisdictions.EU,
+                    jurisdictions.EEA,
+                    jurisdictions.UK
+                ],
+                code: 'GDPR'
+            },
+            {
+                sets: [
+                    jurisdictions.CH
+                ],
+                code: 'CH'
+            },
+            {
+                sets: [
+                    jurisdictions.BR
+                ],
+                code: 'BR'
+            },
+            {
+                sets: [
+                    jurisdictions.CA
+                ],
+                code: 'PIPEDA'
+            },
+            {
+                sets: [
+                    jurisdictions.AU
+                ],
+                code: 'AU'
+            },
+            {
+                sets: [
+                    jurisdictions.JP
+                ],
+                code: 'APPI'
+            },
+            {
+                sets: [
+                    jurisdictions.KR
+                ],
+                code: 'PIPA'
+            }
+        ];
+        for (const { sets, code } of jurisdictionMap)if (sets.some((set)=>set.has(countryCode))) {
+            showConsentBanner = true;
+            jurisdictionCode = code;
+            break;
+        }
+    }
+    const message = JurisdictionMessages[jurisdictionCode];
+    return {
+        showConsentBanner,
+        jurisdictionCode,
+        message
+    };
+}
+const verifyConsent = os.consent.verify.handler(async ({ input, context })=>{
+    const typedContext = context;
+    const logger = typedContext.logger;
+    logger.info('Handling verify-consent request');
+    const { type, subjectId, externalSubjectId, domain, policyId, preferences } = input;
+    logger.debug('Request parameters', {
+        type,
+        subjectId,
+        externalSubjectId,
+        domain,
+        policyId,
+        preferences
+    });
+    try {
+        const subject = await typedContext.registry.findOrCreateSubject({
+            subjectId,
+            externalSubjectId,
+            ipAddress: typedContext.ipAddress || 'unknown'
+        });
+        if (!subject) throw new server_namespaceObject.ORPCError('SUBJECT_NOT_FOUND', {
+            data: {
+                subjectId,
+                externalSubjectId
+            }
+        });
+        const domainRecord = await typedContext.registry.findDomain(domain);
+        if (!domainRecord) throw new server_namespaceObject.ORPCError('DOMAIN_NOT_FOUND', {
+            data: {
+                domain
+            }
+        });
+        if ('cookie_banner' === type && (!preferences || 0 === preferences.length)) throw new server_namespaceObject.ORPCError('COOKIE_BANNER_PREFERENCES_REQUIRED', {
+            data: {
+                type: 'cookie_banner'
+            }
+        });
+        const purposePromises = preferences?.map((purpose)=>typedContext.registry.findConsentPurposeByCode(purpose));
+        const rawPurposes = await Promise.all(purposePromises ?? []);
+        const purposeIds = rawPurposes.filter((purpose)=>null !== purpose).map((purpose)=>purpose.id);
+        if (purposeIds.length !== (preferences?.length ?? 0)) throw new server_namespaceObject.ORPCError('PURPOSES_NOT_FOUND', {
+            data: {
+                preferences: preferences ?? [],
+                foundPurposes: rawPurposes.filter((p)=>null !== p).map((p)=>p.code)
+            }
+        });
+        if (policyId) {
+            const policy = await typedContext.registry.findConsentPolicyById(policyId);
+            if (!policy || policy.type !== type) throw new server_namespaceObject.ORPCError('POLICY_NOT_FOUND', {
+                data: {
+                    policyId,
+                    type
+                }
+            });
+            return await checkPolicyConsent({
+                policyId: policy.id,
+                subjectId: subject.id,
+                domainId: domainRecord.id,
+                purposeIds,
+                type,
+                context: typedContext
+            });
+        }
+        const latestPolicy = await typedContext.registry.findOrCreatePolicy(type);
+        if (!latestPolicy) throw new server_namespaceObject.ORPCError('POLICY_NOT_FOUND', {
+            data: {
+                policyId: 'latest',
+                type
+            }
+        });
+        return await checkPolicyConsent({
+            policyId: latestPolicy.id,
+            subjectId: subject.id,
+            domainId: domainRecord.id,
+            purposeIds,
+            type,
+            context: typedContext
+        });
+    } catch (error) {
+        logger.error('Error in verify-consent handler', {
+            error: error instanceof Error ? error.message : String(error),
+            errorType: error instanceof Error ? error.constructor.name : typeof error
+        });
+        if (error instanceof server_namespaceObject.ORPCError) throw error;
+        throw new server_namespaceObject.ORPCError('INTERNAL_SERVER_ERROR', {
+            message: error instanceof Error ? error.message : String(error)
+        });
+    }
+});
+async function checkPolicyConsent({ policyId, subjectId, domainId, purposeIds, type, context }) {
+    const { registry, adapter } = context;
+    const rawConsents = await adapter.findMany({
+        model: 'consent',
+        where: [
+            {
+                field: 'subjectId',
+                value: subjectId
+            },
+            {
+                field: 'policyId',
+                value: policyId
+            },
+            {
+                field: 'domainId',
+                value: domainId
+            }
+        ],
+        sortBy: {
+            field: 'givenAt',
+            direction: 'desc'
+        }
+    });
+    const filteredConsents = rawConsents.filter((consent)=>{
+        if (!purposeIds) return true;
+        return purposeIds.every((id)=>consent.purposeIds.some((purposeId)=>purposeId === id));
+    });
+    await registry.createAuditLog({
+        subjectId,
+        entityType: 'consent_policy',
+        entityId: policyId,
+        actionType: 'verify_consent',
+        metadata: {
+            type,
+            policyId,
+            purposeIds,
+            success: 0 !== filteredConsents.length,
+            ...filteredConsents.length > 0 ? {
+                consentId: filteredConsents[0]?.id
+            } : {}
+        }
+    });
+    if (0 === rawConsents.length) throw new server_namespaceObject.ORPCError('NO_CONSENT_FOUND', {
+        data: {
+            policyId,
+            subjectId,
+            domainId
+        }
+    });
+    if (0 === filteredConsents.length) throw new server_namespaceObject.ORPCError('NO_CONSENT_FOUND', {
+        data: {
+            policyId,
+            subjectId,
+            domainId
+        }
+    });
+    return {
+        isValid: true,
+        consent: filteredConsents[0]
+    };
+}
+const consentHandlers = {
+    post: postConsent,
+    showBanner: show_banner_handler_showConsentBanner,
+    verify: verifyConsent
+};
+var package_namespaceObject = JSON.parse('{"i8":"1.2.0-canary.0"}');
+const statusHandler = os.meta.status.handler(({ context })=>{
+    const typedContext = context;
+    const headers = typedContext.headers;
+    const normalizeHeader = (value)=>{
+        if (!value) return null;
+        return Array.isArray(value) ? value[0] ?? null : value;
+    };
+    const countryCode = normalizeHeader(headers?.get('cf-ipcountry')) ?? normalizeHeader(headers?.get('x-vercel-ip-country')) ?? normalizeHeader(headers?.get('x-amz-cf-ipcountry')) ?? normalizeHeader(headers?.get('x-country-code'));
+    const regionCode = normalizeHeader(headers?.get('x-vercel-ip-country-region')) ?? normalizeHeader(headers?.get('x-region-code'));
+    return {
+        status: 'ok',
+        version: package_namespaceObject.i8,
+        timestamp: new Date(),
+        storage: {
+            type: typedContext.adapter?.id ?? 'MemoryAdapter',
+            available: !!typedContext.adapter
+        },
+        client: {
+            ip: typedContext.ipAddress ?? null,
+            userAgent: typedContext.userAgent ?? null,
+            region: {
+                countryCode,
+                regionCode
+            }
+        }
+    };
+});
+const metaHandlers = {
+    status: statusHandler
+};
+const router = os.router({
+    consent: consentHandlers,
+    meta: metaHandlers
+});
+exports.router = __webpack_exports__.router;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "router"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});