@c15t/backend 1.2.0-canary.9 → 1.2.1

package/dist/contracts.cjs

@@ -0,0 +1,708 @@
+"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__, {
+    os: ()=>os,
+    contracts: ()=>config
+});
+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().nullish(),
+    legalBasis: external_zod_namespaceObject.z.string().nullish(),
+    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())
+});
+const baseConsentSchema = external_zod_namespaceObject.z.object({
+    subjectId: external_zod_namespaceObject.z.string().optional(),
+    externalSubjectId: external_zod_namespaceObject.z.string().optional(),
+    domain: external_zod_namespaceObject.z.string(),
+    type: PolicyTypeSchema,
+    metadata: external_zod_namespaceObject.z.record(external_zod_namespaceObject.z.unknown()).optional()
+});
+const cookieBannerSchema = baseConsentSchema.extend({
+    type: external_zod_namespaceObject.z.literal('cookie_banner'),
+    preferences: external_zod_namespaceObject.z.record(external_zod_namespaceObject.z.boolean())
+});
+const policyBasedSchema = baseConsentSchema.extend({
+    type: external_zod_namespaceObject.z["enum"]([
+        'privacy_policy',
+        'dpa',
+        'terms_and_conditions'
+    ]),
+    policyId: external_zod_namespaceObject.z.string().optional(),
+    preferences: external_zod_namespaceObject.z.record(external_zod_namespaceObject.z.boolean()).optional()
+});
+const otherConsentSchema = baseConsentSchema.extend({
+    type: external_zod_namespaceObject.z["enum"]([
+        'marketing_communications',
+        'age_verification',
+        'other'
+    ]),
+    preferences: external_zod_namespaceObject.z.record(external_zod_namespaceObject.z.boolean()).optional()
+});
+const 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 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);
+exports.contracts = __webpack_exports__.contracts;
+exports.os = __webpack_exports__.os;
+for(var __webpack_i__ in __webpack_exports__)if (-1 === [
+    "contracts",
+    "os"
+].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});