@c15t/backend 1.2.0-canary.13 → 1.2.0-canary.2

package/dist/contracts.cjs

@@ -1,708 +0,0 @@
-"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().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())
-});
-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
-});