@c15t/backend 1.5.0 → 1.6.0

package/dist/v2/contracts/index.cjs

@@ -0,0 +1,644 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __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_fumadb_namespaceObject = require("fumadb");
+const schema_namespaceObject = require("fumadb/schema");
+const auditLogTable = (0, schema_namespaceObject.table)('auditLog', {
+    id: (0, schema_namespaceObject.idColumn)('id', 'varchar(255)'),
+    entityType: (0, schema_namespaceObject.column)('entityType', 'string'),
+    entityId: (0, schema_namespaceObject.column)('entityId', 'string'),
+    actionType: (0, schema_namespaceObject.column)('actionType', 'string'),
+    subjectId: (0, schema_namespaceObject.column)('subjectId', 'string').nullable(),
+    ipAddress: (0, schema_namespaceObject.column)('ipAddress', 'string').nullable(),
+    userAgent: (0, schema_namespaceObject.column)('userAgent', 'string').nullable(),
+    changes: (0, schema_namespaceObject.column)('changes', 'json').nullable(),
+    metadata: (0, schema_namespaceObject.column)('metadata', 'json').nullable(),
+    createdAt: (0, schema_namespaceObject.column)('createdAt', 'timestamp').defaultTo$('now'),
+    eventTimezone: (0, schema_namespaceObject.column)('eventTimezone', 'string').defaultTo$(()=>'UTC')
+});
+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.string(), external_zod_namespaceObject.z.unknown()).optional(),
+    metadata: external_zod_namespaceObject.z.record(external_zod_namespaceObject.z.string(), external_zod_namespaceObject.z.unknown()).optional(),
+    createdAt: external_zod_namespaceObject.z.date().prefault(()=>new Date()),
+    eventTimezone: external_zod_namespaceObject.z.string().prefault('UTC')
+});
+const consentTable = (0, schema_namespaceObject.table)('consent', {
+    id: (0, schema_namespaceObject.idColumn)('id', 'varchar(255)'),
+    subjectId: (0, schema_namespaceObject.column)('subjectId', 'string'),
+    domainId: (0, schema_namespaceObject.column)('domainId', 'string'),
+    policyId: (0, schema_namespaceObject.column)('policyId', 'string').nullable(),
+    purposeIds: (0, schema_namespaceObject.column)('purposeIds', 'json'),
+    metadata: (0, schema_namespaceObject.column)('metadata', 'json').nullable(),
+    ipAddress: (0, schema_namespaceObject.column)('ipAddress', 'string').nullable(),
+    userAgent: (0, schema_namespaceObject.column)('userAgent', 'string').nullable(),
+    status: (0, schema_namespaceObject.column)('status', 'string').defaultTo$(()=>'active'),
+    withdrawalReason: (0, schema_namespaceObject.column)('withdrawalReason', 'string').nullable(),
+    givenAt: (0, schema_namespaceObject.column)('givenAt', 'timestamp').defaultTo$('now'),
+    validUntil: (0, schema_namespaceObject.column)('validUntil', 'timestamp').nullable(),
+    isActive: (0, schema_namespaceObject.column)('isActive', 'bool').defaultTo$(()=>true)
+});
+const consentStatusSchema = external_zod_namespaceObject.z["enum"]([
+    'active',
+    'withdrawn',
+    'expired'
+]);
+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.string(), external_zod_namespaceObject.z.unknown()).nullish(),
+    policyId: external_zod_namespaceObject.z.string().optional(),
+    ipAddress: external_zod_namespaceObject.z.string().nullish(),
+    userAgent: external_zod_namespaceObject.z.string().nullish(),
+    status: consentStatusSchema.prefault('active'),
+    withdrawalReason: external_zod_namespaceObject.z.string().nullish(),
+    givenAt: external_zod_namespaceObject.z.date().prefault(()=>new Date()),
+    validUntil: external_zod_namespaceObject.z.date().nullish(),
+    isActive: external_zod_namespaceObject.z.boolean().prefault(true)
+});
+const consentPolicyTable = (0, schema_namespaceObject.table)('consentPolicy', {
+    id: (0, schema_namespaceObject.idColumn)('id', 'varchar(255)'),
+    version: (0, schema_namespaceObject.column)('version', 'string'),
+    type: (0, schema_namespaceObject.column)('type', 'string'),
+    name: (0, schema_namespaceObject.column)('name', 'string'),
+    effectiveDate: (0, schema_namespaceObject.column)('effectiveDate', 'timestamp'),
+    expirationDate: (0, schema_namespaceObject.column)('expirationDate', 'timestamp').nullable(),
+    content: (0, schema_namespaceObject.column)('content', 'string'),
+    contentHash: (0, schema_namespaceObject.column)('contentHash', 'string'),
+    isActive: (0, schema_namespaceObject.column)('isActive', 'bool').defaultTo$(()=>true),
+    createdAt: (0, schema_namespaceObject.column)('createdAt', 'timestamp').defaultTo$('now')
+});
+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().nullish(),
+    content: external_zod_namespaceObject.z.string(),
+    contentHash: external_zod_namespaceObject.z.string(),
+    isActive: external_zod_namespaceObject.z.boolean().prefault(true),
+    createdAt: external_zod_namespaceObject.z.date().prefault(()=>new Date())
+});
+const consentPurposeTable = (0, schema_namespaceObject.table)('consentPurpose', {
+    id: (0, schema_namespaceObject.idColumn)('id', 'varchar(255)'),
+    code: (0, schema_namespaceObject.column)('code', 'string'),
+    name: (0, schema_namespaceObject.column)('name', 'string'),
+    description: (0, schema_namespaceObject.column)("description", 'string'),
+    isEssential: (0, schema_namespaceObject.column)('isEssential', 'bool'),
+    dataCategory: (0, schema_namespaceObject.column)('dataCategory', 'string').nullable(),
+    legalBasis: (0, schema_namespaceObject.column)('legalBasis', 'string').nullable(),
+    isActive: (0, schema_namespaceObject.column)('isActive', 'bool').defaultTo$(()=>true),
+    createdAt: (0, schema_namespaceObject.column)('createdAt', 'timestamp').defaultTo$('now'),
+    updatedAt: (0, schema_namespaceObject.column)('updatedAt', 'timestamp').defaultTo$('now')
+});
+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(),
+    dataCategory: external_zod_namespaceObject.z.string().nullish(),
+    legalBasis: external_zod_namespaceObject.z.string().nullish(),
+    isActive: external_zod_namespaceObject.z.boolean().prefault(true),
+    createdAt: external_zod_namespaceObject.z.date().prefault(()=>new Date()),
+    updatedAt: external_zod_namespaceObject.z.date().prefault(()=>new Date())
+});
+const consentRecordTable = (0, schema_namespaceObject.table)('consentRecord', {
+    id: (0, schema_namespaceObject.idColumn)('id', 'varchar(255)'),
+    subjectId: (0, schema_namespaceObject.column)('subjectId', 'string'),
+    consentId: (0, schema_namespaceObject.column)('consentId', 'string').nullable(),
+    actionType: (0, schema_namespaceObject.column)('actionType', 'string'),
+    details: (0, schema_namespaceObject.column)('details', 'json').nullable(),
+    createdAt: (0, schema_namespaceObject.column)('createdAt', 'timestamp').defaultTo$('now')
+});
+external_zod_namespaceObject.z.object({
+    id: external_zod_namespaceObject.z.string(),
+    subjectId: external_zod_namespaceObject.z.string(),
+    consentId: external_zod_namespaceObject.z.string().nullish(),
+    actionType: external_zod_namespaceObject.z.string(),
+    details: external_zod_namespaceObject.z.record(external_zod_namespaceObject.z.string(), external_zod_namespaceObject.z.unknown()).nullish(),
+    createdAt: external_zod_namespaceObject.z.date().prefault(()=>new Date())
+});
+const domainTable = (0, schema_namespaceObject.table)('domain', {
+    id: (0, schema_namespaceObject.idColumn)('id', 'varchar(255)'),
+    name: (0, schema_namespaceObject.column)('name', 'string').unique(),
+    description: (0, schema_namespaceObject.column)("description", 'string').nullable(),
+    allowedOrigins: (0, schema_namespaceObject.column)('allowedOrigins', 'json').nullable(),
+    isVerified: (0, schema_namespaceObject.column)('isVerified', 'bool').defaultTo$(()=>true),
+    isActive: (0, schema_namespaceObject.column)('isActive', 'bool').defaultTo$(()=>true),
+    createdAt: (0, schema_namespaceObject.column)('createdAt', 'timestamp').defaultTo$('now'),
+    updatedAt: (0, schema_namespaceObject.column)('updatedAt', 'timestamp').defaultTo$('now')
+});
+external_zod_namespaceObject.z.object({
+    id: external_zod_namespaceObject.z.string(),
+    name: external_zod_namespaceObject.z.string(),
+    description: external_zod_namespaceObject.z.string().nullish(),
+    allowedOrigins: external_zod_namespaceObject.z.array(external_zod_namespaceObject.z.string()).nullish(),
+    isVerified: external_zod_namespaceObject.z.boolean().prefault(true),
+    isActive: external_zod_namespaceObject.z.boolean().prefault(true),
+    createdAt: external_zod_namespaceObject.z.date().prefault(()=>new Date()),
+    updatedAt: external_zod_namespaceObject.z.date().prefault(()=>new Date())
+});
+const subjectTable = (0, schema_namespaceObject.table)('subject', {
+    id: (0, schema_namespaceObject.idColumn)('id', 'varchar(255)'),
+    isIdentified: (0, schema_namespaceObject.column)('isIdentified', 'bool').defaultTo$(()=>false),
+    externalId: (0, schema_namespaceObject.column)('externalId', 'string').nullable(),
+    identityProvider: (0, schema_namespaceObject.column)('identityProvider', 'string').nullable(),
+    lastIpAddress: (0, schema_namespaceObject.column)('lastIpAddress', 'string').nullable(),
+    subjectTimezone: (0, schema_namespaceObject.column)('subjectTimezone', 'string').nullable(),
+    createdAt: (0, schema_namespaceObject.column)('createdAt', 'timestamp').defaultTo$('now'),
+    updatedAt: (0, schema_namespaceObject.column)('updatedAt', 'timestamp').defaultTo$('now')
+});
+external_zod_namespaceObject.z.object({
+    id: external_zod_namespaceObject.z.string(),
+    isIdentified: external_zod_namespaceObject.z.boolean().prefault(false),
+    externalId: external_zod_namespaceObject.z.string().nullish(),
+    identityProvider: external_zod_namespaceObject.z.string().nullish(),
+    lastIpAddress: external_zod_namespaceObject.z.string().optional(),
+    subjectTimezone: external_zod_namespaceObject.z.string().nullish(),
+    createdAt: external_zod_namespaceObject.z.date().prefault(()=>new Date()),
+    updatedAt: external_zod_namespaceObject.z.date().prefault(()=>new Date())
+});
+const v1 = (0, schema_namespaceObject.schema)({
+    version: '1.0.0',
+    tables: {
+        subject: subjectTable,
+        domain: domainTable,
+        consentPolicy: consentPolicyTable,
+        consentPurpose: consentPurposeTable,
+        consent: consentTable,
+        auditLog: auditLogTable,
+        consentRecord: consentRecordTable
+    },
+    relations: {
+        subject: ({ many })=>({
+                consents: many('consent'),
+                consentRecords: many('consentRecord'),
+                auditLogs: many('auditLog')
+            }),
+        domain: ({ many })=>({
+                consents: many('consent')
+            }),
+        consentPolicy: ({ many })=>({
+                consents: many('consent')
+            }),
+        consentPurpose: ()=>({}),
+        consent: ({ one, many })=>({
+                subject: one('subject', [
+                    'subjectId',
+                    'id'
+                ]).foreignKey(),
+                domain: one('domain', [
+                    'domainId',
+                    'id'
+                ]).foreignKey(),
+                policy: one('consentPolicy', [
+                    'policyId',
+                    'id'
+                ]).foreignKey(),
+                consentRecords: many('consentRecord')
+            }),
+        consentRecord: ({ one })=>({
+                subject: one('subject', [
+                    'subjectId',
+                    'id'
+                ]).foreignKey(),
+                consent: one('consent', [
+                    'consentId',
+                    'id'
+                ]).foreignKey()
+            }),
+        auditLog: ({ one })=>({
+                subject: one('subject', [
+                    'subjectId',
+                    'id'
+                ]).foreignKey()
+            })
+    }
+});
+(0, external_fumadb_namespaceObject.fumadb)({
+    namespace: 'c15t',
+    schemas: [
+        v1
+    ]
+});
+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.string(), 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.string(), 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.string(), 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.string(), 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,
+        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()))
+        }),
+        error: 'Invalid input parameters'
+    },
+    SUBJECT_CREATION_FAILED: {
+        status: 400,
+        data: external_zod_namespaceObject.z.object({
+            subjectId: external_zod_namespaceObject.z.string().optional(),
+            externalSubjectId: external_zod_namespaceObject.z.string().optional()
+        }),
+        error: 'Failed to create or find subject'
+    },
+    DOMAIN_CREATION_FAILED: {
+        status: 500,
+        data: external_zod_namespaceObject.z.object({
+            domain: external_zod_namespaceObject.z.string()
+        }),
+        error: 'Failed to create or find domain'
+    },
+    POLICY_NOT_FOUND: {
+        status: 404,
+        data: external_zod_namespaceObject.z.object({
+            policyId: external_zod_namespaceObject.z.string(),
+            type: external_zod_namespaceObject.z.string()
+        }),
+        error: 'Policy not found'
+    },
+    POLICY_INACTIVE: {
+        status: 409,
+        data: external_zod_namespaceObject.z.object({
+            policyId: external_zod_namespaceObject.z.string(),
+            type: external_zod_namespaceObject.z.string()
+        }),
+        error: 'Policy is not active'
+    },
+    POLICY_CREATION_FAILED: {
+        status: 500,
+        data: external_zod_namespaceObject.z.object({
+            type: external_zod_namespaceObject.z.string()
+        }),
+        error: 'Failed to create or find policy'
+    },
+    PURPOSE_CREATION_FAILED: {
+        status: 500,
+        data: external_zod_namespaceObject.z.object({
+            purposeCode: external_zod_namespaceObject.z.string()
+        }),
+        error: 'Failed to create consent purpose'
+    },
+    CONSENT_CREATION_FAILED: {
+        status: 500,
+        data: external_zod_namespaceObject.z.object({
+            subjectId: external_zod_namespaceObject.z.string(),
+            domain: external_zod_namespaceObject.z.string()
+        }),
+        error: 'Failed to create consent record'
+    }
+}).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.string(), external_zod_namespaceObject.z.unknown()).optional(),
+    givenAt: external_zod_namespaceObject.z.date()
+}));
+const branding = [
+    'c15t',
+    'consent',
+    'none'
+];
+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 TitleDescriptionSchema = external_zod_namespaceObject.z.object({
+    title: external_zod_namespaceObject.z.string(),
+    description: external_zod_namespaceObject.z.string()
+});
+const TranslationsSchema = external_zod_namespaceObject.z.object({
+    common: external_zod_namespaceObject.z.object({
+        acceptAll: external_zod_namespaceObject.z.string(),
+        rejectAll: external_zod_namespaceObject.z.string(),
+        customize: external_zod_namespaceObject.z.string(),
+        save: external_zod_namespaceObject.z.string()
+    }),
+    cookieBanner: TitleDescriptionSchema,
+    consentManagerDialog: TitleDescriptionSchema,
+    consentTypes: external_zod_namespaceObject.z.object({
+        experience: TitleDescriptionSchema,
+        functionality: TitleDescriptionSchema,
+        marketing: TitleDescriptionSchema,
+        measurement: TitleDescriptionSchema,
+        necessary: TitleDescriptionSchema
+    })
+});
+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()
+    }),
+    translations: external_zod_namespaceObject.z.object({
+        language: external_zod_namespaceObject.z.string(),
+        translations: TranslationsSchema
+    }),
+    branding: external_zod_namespaceObject.z["enum"](branding)
+}));
+const verifyConsentInputSchema = external_zod_namespaceObject.z.strictObject({
+    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()
+});
+const verify_contract_consentSchema = external_zod_namespaceObject.z.looseObject({
+    id: external_zod_namespaceObject.z.string(),
+    purposeIds: external_zod_namespaceObject.z.array(external_zod_namespaceObject.z.string())
+});
+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,
+        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())
+        }),
+        error: 'Invalid input parameters'
+    },
+    SUBJECT_NOT_FOUND: {
+        status: 404,
+        data: external_zod_namespaceObject.z.object({
+            subjectId: external_zod_namespaceObject.z.string().optional(),
+            externalSubjectId: external_zod_namespaceObject.z.string().optional()
+        }),
+        error: 'Subject not found'
+    },
+    DOMAIN_NOT_FOUND: {
+        status: 404,
+        data: external_zod_namespaceObject.z.object({
+            domain: external_zod_namespaceObject.z.string()
+        }),
+        error: 'Domain not found'
+    },
+    POLICY_NOT_FOUND: {
+        status: 404,
+        data: external_zod_namespaceObject.z.object({
+            policyId: external_zod_namespaceObject.z.string(),
+            type: external_zod_namespaceObject.z.string()
+        }),
+        error: 'Policy not found or invalid'
+    },
+    PURPOSES_NOT_FOUND: {
+        status: 404,
+        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())
+        }),
+        error: 'Could not find all specified purposes'
+    },
+    COOKIE_BANNER_PREFERENCES_REQUIRED: {
+        status: 400,
+        data: external_zod_namespaceObject.z.object({
+            type: external_zod_namespaceObject.z.literal('cookie_banner')
+        }),
+        error: 'Preferences are required for cookie banner consent'
+    },
+    NO_CONSENT_FOUND: {
+        status: 404,
+        data: external_zod_namespaceObject.z.object({
+            policyId: external_zod_namespaceObject.z.string(),
+            subjectId: external_zod_namespaceObject.z.string(),
+            domainId: external_zod_namespaceObject.z.string()
+        }),
+        error: 'No consent found for the given policy'
+    }
+}).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(),
+    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
+});