@c15t/backend 1.5.0 → 1.6.0

package/dist/v2/db/registry/index.d.ts

@@ -0,0 +1,102 @@
+import type { Registry } from './types';
+export declare const createRegistry: (ctx: Registry) => {
+    findDomainByName: (name: string) => Promise<{
+        id: string;
+        name: string;
+        description: string | null;
+        allowedOrigins: unknown;
+        isVerified: boolean;
+        isActive: boolean;
+        createdAt: Date;
+        updatedAt: Date;
+    } | null>;
+    findOrCreateDomain: (name: string) => Promise<{
+        id: string;
+        name: string;
+        description: string | null;
+        allowedOrigins: unknown;
+        isVerified: boolean;
+        isActive: boolean;
+        createdAt: Date;
+        updatedAt: Date;
+    }>;
+    findConsentPolicyById: (policyId: string) => Promise<{
+        id: string;
+        version: string;
+        type: string;
+        name: string;
+        effectiveDate: Date;
+        expirationDate: Date | null;
+        content: string;
+        contentHash: string;
+        isActive: boolean;
+        createdAt: Date;
+    } | null>;
+    findOrCreatePolicy: (type: import("../schema").PolicyType) => Promise<{
+        id: string;
+        version: string;
+        type: string;
+        name: string;
+        effectiveDate: Date;
+        expirationDate: Date | null;
+        content: string;
+        contentHash: string;
+        isActive: boolean;
+        createdAt: Date;
+    }>;
+    findOrCreateConsentPurposeByCode: (code: string) => Promise<{
+        id: string;
+        code: string;
+        name: string;
+        description: string;
+        isEssential: boolean;
+        dataCategory: string | null;
+        legalBasis: string | null;
+        isActive: boolean;
+        createdAt: Date;
+        updatedAt: Date;
+    }>;
+    createConsent: (consent: Omit<import("../schema").Consent, "id" | "createdAt"> & Partial<import("../schema").Consent>) => Promise<{
+        id: string;
+        subjectId: string;
+        domainId: string;
+        policyId: string | null;
+        purposeIds: unknown;
+        metadata: unknown;
+        ipAddress: string | null;
+        userAgent: string | null;
+        status: string;
+        withdrawalReason: string | null;
+        givenAt: Date;
+        validUntil: Date | null;
+        isActive: boolean;
+    }>;
+    findOrCreateSubject: ({ subjectId, externalSubjectId, ipAddress, }: {
+        subjectId?: string;
+        externalSubjectId?: string;
+        ipAddress?: string;
+    }) => Promise<{
+        id: string;
+        isIdentified: boolean;
+        externalId: string | null;
+        identityProvider: string | null;
+        lastIpAddress: string | null;
+        subjectTimezone: string | null;
+        createdAt: Date;
+        updatedAt: Date;
+    } | null>;
+    createAuditLog: (auditLog: Omit<import("../schema").AuditLog, "id" | "createdAt"> & Partial<import("../schema").AuditLog>) => Promise<{
+        id: string;
+        entityType: string;
+        entityId: string;
+        actionType: string;
+        subjectId: string | null;
+        ipAddress: string | null;
+        userAgent: string | null;
+        changes: unknown;
+        metadata: unknown;
+        createdAt: Date;
+        eventTimezone: string;
+    }>;
+};
+//# sourceMappingURL=index.d.ts.map

package/dist/v2/db/registry/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/v2/db/registry/index.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAExC,eAAO,MAAM,cAAc,GAAI,KAAK,QAAQ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAjC,CAAC;yBAA8B,CAAC;iBAEvC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;CAOJ,CAAC"}

package/dist/v2/db/registry/subject.d.ts

@@ -0,0 +1,18 @@
+import type { Registry } from './types';
+export declare function subjectRegistry({ db, ctx }: Registry): {
+    findOrCreateSubject: ({ subjectId, externalSubjectId, ipAddress, }: {
+        subjectId?: string;
+        externalSubjectId?: string;
+        ipAddress?: string;
+    }) => Promise<{
+        id: string;
+        isIdentified: boolean;
+        externalId: string | null;
+        identityProvider: string | null;
+        lastIpAddress: string | null;
+        subjectTimezone: string | null;
+        createdAt: Date;
+        updatedAt: Date;
+    } | null>;
+};
+//# sourceMappingURL=subject.d.ts.map

package/dist/v2/db/registry/subject.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"subject.d.ts","sourceRoot":"","sources":["../../../../src/v2/db/registry/subject.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AAGxC,wBAAgB,eAAe,CAAC,EAAE,EAAE,EAAE,GAAG,EAAE,EAAE,QAAQ;wEAOhD;QACF,SAAS,CAAC,EAAE,MAAM,CAAC;QACnB,iBAAiB,CAAC,EAAE,MAAM,CAAC;QAC3B,SAAS,CAAC,EAAE,MAAM,CAAC;KACnB;;;;;;;;;;EAqFF"}

package/dist/v2/db/registry/subject.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=subject.test.d.ts.map

package/dist/v2/db/registry/subject.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"subject.test.d.ts","sourceRoot":"","sources":["../../../../src/v2/db/registry/subject.test.ts"],"names":[],"mappings":""}

package/dist/v2/db/registry/types.d.ts

@@ -0,0 +1,10 @@
+import type { createLogger } from '@doubletie/logger';
+import type { InferFumaDB } from 'fumadb';
+import type { DB } from '../schema';
+export interface Registry {
+    db: ReturnType<InferFumaDB<typeof DB>['orm']>;
+    ctx: {
+        logger: ReturnType<typeof createLogger>;
+    };
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/v2/db/registry/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/v2/db/registry/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AACtD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,QAAQ,CAAC;AAC1C,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,gBAAgB,CAAC;AAEzC,MAAM,WAAW,QAAQ;IACxB,EAAE,EAAE,UAAU,CAAC,WAAW,CAAC,OAAO,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC;IAC9C,GAAG,EAAE;QACJ,MAAM,EAAE,UAAU,CAAC,OAAO,YAAY,CAAC,CAAC;KACxC,CAAC;CACF"}

package/dist/v2/db/registry/utils/generate-id.d.ts

@@ -0,0 +1,25 @@
+import type { InferFumaDB } from 'fumadb';
+import type { DB } from '../../schema';
+import type { C15TContext } from '../../../types';
+type Tables = InferFumaDB<typeof DB>['schemas'][-1]['tables'];
+/**
+ * Generates a unique ID for the specified model with conflict handling
+ *
+ * @param db - Database ORM instance
+ * @param model - The model/table name to generate ID for
+ * @param ctx - Application context containing logger (optional)
+ * @param options - Configuration options for ID generation
+ * @returns Promise resolving to a unique ID
+ *
+ * @throws {Error} When max retry attempts are exceeded
+ */
+export declare function generateUniqueId(db: ReturnType<InferFumaDB<typeof DB>['orm']>, model: keyof Tables, ctx?: Partial<C15TContext> | undefined, options?: {
+    /** Maximum number of retry attempts (default: 10) */
+    maxRetries?: number;
+    /** Current retry attempt (used internally) */
+    attempt?: number;
+    /** Base delay for exponential backoff in ms (default: 5) */
+    baseDelay?: number;
+}): Promise<string>;
+export {};
+//# sourceMappingURL=generate-id.d.ts.map

package/dist/v2/db/registry/utils/generate-id.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate-id.d.ts","sourceRoot":"","sources":["../../../../../src/v2/db/registry/utils/generate-id.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,QAAQ,CAAC;AAC1C,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,gBAAgB,CAAC;AACzC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAE9C,KAAK,MAAM,GAAG,WAAW,CAAC,OAAO,EAAE,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC;AA2C9D;;;;;;;;;;GAUG;AACH,wBAAsB,gBAAgB,CACrC,EAAE,EAAE,UAAU,CAAC,WAAW,CAAC,OAAO,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,EAC7C,KAAK,EAAE,MAAM,MAAM,EACnB,GAAG,CAAC,EAAE,OAAO,CAAC,WAAW,CAAC,GAAG,SAAS,EACtC,OAAO,GAAE;IACR,qDAAqD;IACrD,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,8CAA8C;IAC9C,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,4DAA4D;IAC5D,SAAS,CAAC,EAAE,MAAM,CAAC;CACd,GACJ,OAAO,CAAC,MAAM,CAAC,CA8DjB"}

package/dist/v2/db/registry/utils/generate-id.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=generate-id.test.d.ts.map

package/dist/v2/db/registry/utils/generate-id.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate-id.test.d.ts","sourceRoot":"","sources":["../../../../../src/v2/db/registry/utils/generate-id.test.ts"],"names":[],"mappings":""}

package/dist/v2/db/registry/utils.d.ts

@@ -0,0 +1,25 @@
+import type { InferFumaDB } from 'fumadb';
+import type { DB } from '../schema';
+import type { C15TContext } from '../../types';
+type Tables = InferFumaDB<typeof DB>['schemas'][-1]['tables'];
+/**
+ * Generates a unique ID for the specified model with conflict handling
+ *
+ * @param db - Database ORM instance
+ * @param model - The model/table name to generate ID for
+ * @param ctx - Application context containing logger (optional)
+ * @param options - Configuration options for ID generation
+ * @returns Promise resolving to a unique ID
+ *
+ * @throws {Error} When max retry attempts are exceeded
+ */
+export declare function generateUniqueId(db: ReturnType<InferFumaDB<typeof DB>['orm']>, model: keyof Tables, ctx?: Partial<C15TContext> | undefined, options?: {
+    /** Maximum number of retry attempts (default: 10) */
+    maxRetries?: number;
+    /** Current retry attempt (used internally) */
+    attempt?: number;
+    /** Base delay for exponential backoff in ms (default: 5) */
+    baseDelay?: number;
+}): Promise<string>;
+export {};
+//# sourceMappingURL=utils.d.ts.map

package/dist/v2/db/registry/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../../src/v2/db/registry/utils.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,QAAQ,CAAC;AAC1C,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,gBAAgB,CAAC;AACzC,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAE9C,KAAK,MAAM,GAAG,WAAW,CAAC,OAAO,EAAE,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC;AA2C9D;;;;;;;;;;GAUG;AACH,wBAAsB,gBAAgB,CACrC,EAAE,EAAE,UAAU,CAAC,WAAW,CAAC,OAAO,EAAE,CAAC,CAAC,KAAK,CAAC,CAAC,EAC7C,KAAK,EAAE,MAAM,MAAM,EACnB,GAAG,CAAC,EAAE,OAAO,CAAC,WAAW,CAAC,GAAG,SAAS,EACtC,OAAO,GAAE;IACR,qDAAqD;IACrD,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,8CAA8C;IAC9C,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,4DAA4D;IAC5D,SAAS,CAAC,EAAE,MAAM,CAAC;CACd,GACJ,OAAO,CAAC,MAAM,CAAC,CA8DjB"}

package/dist/v2/db/schema/1.0.0/audit-log.d.ts

@@ -0,0 +1,29 @@
+import { z } from 'zod';
+export declare const auditLogTable: import("fumadb/schema").Table<{
+    id: import("fumadb/schema").IdColumn<"varchar(255)", string, string>;
+    entityType: import("fumadb/schema").Column<"string", string, string>;
+    entityId: import("fumadb/schema").Column<"string", string, string>;
+    actionType: import("fumadb/schema").Column<"string", string, string>;
+    subjectId: import("fumadb/schema").Column<"string", string | null, string | null>;
+    ipAddress: import("fumadb/schema").Column<"string", string | null, string | null>;
+    userAgent: import("fumadb/schema").Column<"string", string | null, string | null>;
+    changes: import("fumadb/schema").Column<"json", unknown, unknown>;
+    metadata: import("fumadb/schema").Column<"json", unknown, unknown>;
+    createdAt: import("fumadb/schema").Column<"timestamp", Date | null, Date>;
+    eventTimezone: import("fumadb/schema").Column<"string", string | null, string>;
+}, {}>;
+export declare const auditLogSchema: z.ZodObject<{
+    id: z.ZodString;
+    entityType: z.ZodString;
+    entityId: z.ZodString;
+    actionType: z.ZodString;
+    subjectId: z.ZodOptional<z.ZodString>;
+    ipAddress: z.ZodOptional<z.ZodString>;
+    userAgent: z.ZodOptional<z.ZodString>;
+    changes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    createdAt: z.ZodPrefault<z.ZodDate>;
+    eventTimezone: z.ZodPrefault<z.ZodString>;
+}, z.core.$strip>;
+export type AuditLog = z.infer<typeof auditLogSchema>;
+//# sourceMappingURL=audit-log.d.ts.map

package/dist/v2/db/schema/1.0.0/audit-log.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"audit-log.d.ts","sourceRoot":"","sources":["../../../../../src/v2/db/schema/1.0.0/audit-log.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,aAAa;;;;;;;;;;;;MAYxB,CAAC;AAEH,eAAO,MAAM,cAAc;;;;;;;;;;;;iBAYzB,CAAC;AAEH,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC"}

package/dist/v2/db/schema/1.0.0/consent-policy.d.ts

@@ -0,0 +1,45 @@
+import { z } from 'zod';
+export declare const consentPolicyTable: import("fumadb/schema").Table<{
+    id: import("fumadb/schema").IdColumn<"varchar(255)", string, string>;
+    version: import("fumadb/schema").Column<"string", string, string>;
+    type: import("fumadb/schema").Column<"string", string, string>;
+    name: import("fumadb/schema").Column<"string", string, string>;
+    effectiveDate: import("fumadb/schema").Column<"timestamp", Date, Date>;
+    expirationDate: import("fumadb/schema").Column<"timestamp", Date | null, Date | null>;
+    content: import("fumadb/schema").Column<"string", string, string>;
+    contentHash: import("fumadb/schema").Column<"string", string, string>;
+    isActive: import("fumadb/schema").Column<"bool", boolean | null, boolean>;
+    createdAt: import("fumadb/schema").Column<"timestamp", Date | null, Date>;
+}, {}>;
+export declare const PolicyTypeSchema: z.ZodEnum<{
+    cookie_banner: "cookie_banner";
+    privacy_policy: "privacy_policy";
+    dpa: "dpa";
+    terms_and_conditions: "terms_and_conditions";
+    marketing_communications: "marketing_communications";
+    age_verification: "age_verification";
+    other: "other";
+}>;
+export declare const consentPolicySchema: z.ZodObject<{
+    id: z.ZodString;
+    version: z.ZodString;
+    type: z.ZodEnum<{
+        cookie_banner: "cookie_banner";
+        privacy_policy: "privacy_policy";
+        dpa: "dpa";
+        terms_and_conditions: "terms_and_conditions";
+        marketing_communications: "marketing_communications";
+        age_verification: "age_verification";
+        other: "other";
+    }>;
+    name: z.ZodString;
+    effectiveDate: z.ZodDate;
+    expirationDate: z.ZodOptional<z.ZodNullable<z.ZodDate>>;
+    content: z.ZodString;
+    contentHash: z.ZodString;
+    isActive: z.ZodPrefault<z.ZodBoolean>;
+    createdAt: z.ZodPrefault<z.ZodDate>;
+}, z.core.$strip>;
+export type ConsentPolicy = z.infer<typeof consentPolicySchema>;
+export type PolicyType = z.infer<typeof PolicyTypeSchema>;
+//# sourceMappingURL=consent-policy.d.ts.map

package/dist/v2/db/schema/1.0.0/consent-policy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"consent-policy.d.ts","sourceRoot":"","sources":["../../../../../src/v2/db/schema/1.0.0/consent-policy.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,kBAAkB;;;;;;;;;;;MAW7B,CAAC;AAEH,eAAO,MAAM,gBAAgB;;;;;;;;EAQ3B,CAAC;AAEH,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;iBAW9B,CAAC;AAEH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAChE,MAAM,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,gBAAgB,CAAC,CAAC"}

package/dist/v2/db/schema/1.0.0/consent-purpose.d.ts

@@ -0,0 +1,27 @@
+import { z } from 'zod';
+export declare const consentPurposeTable: import("fumadb/schema").Table<{
+    id: import("fumadb/schema").IdColumn<"varchar(255)", string, string>;
+    code: import("fumadb/schema").Column<"string", string, string>;
+    name: import("fumadb/schema").Column<"string", string, string>;
+    description: import("fumadb/schema").Column<"string", string, string>;
+    isEssential: import("fumadb/schema").Column<"bool", boolean, boolean>;
+    dataCategory: import("fumadb/schema").Column<"string", string | null, string | null>;
+    legalBasis: import("fumadb/schema").Column<"string", string | null, string | null>;
+    isActive: import("fumadb/schema").Column<"bool", boolean | null, boolean>;
+    createdAt: import("fumadb/schema").Column<"timestamp", Date | null, Date>;
+    updatedAt: import("fumadb/schema").Column<"timestamp", Date | null, Date>;
+}, {}>;
+export declare const consentPurposeSchema: z.ZodObject<{
+    id: z.ZodString;
+    code: z.ZodString;
+    name: z.ZodString;
+    description: z.ZodString;
+    isEssential: z.ZodBoolean;
+    dataCategory: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    legalBasis: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    isActive: z.ZodPrefault<z.ZodBoolean>;
+    createdAt: z.ZodPrefault<z.ZodDate>;
+    updatedAt: z.ZodPrefault<z.ZodDate>;
+}, z.core.$strip>;
+export type ConsentPurpose = z.infer<typeof consentPurposeSchema>;
+//# sourceMappingURL=consent-purpose.d.ts.map

package/dist/v2/db/schema/1.0.0/consent-purpose.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"consent-purpose.d.ts","sourceRoot":"","sources":["../../../../../src/v2/db/schema/1.0.0/consent-purpose.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,mBAAmB;;;;;;;;;;;MAW9B,CAAC;AAEH,eAAO,MAAM,oBAAoB;;;;;;;;;;;iBAW/B,CAAC;AAEH,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC"}

package/dist/v2/db/schema/1.0.0/consent-record.d.ts

@@ -0,0 +1,19 @@
+import { z } from 'zod';
+export declare const consentRecordTable: import("fumadb/schema").Table<{
+    id: import("fumadb/schema").IdColumn<"varchar(255)", string, string>;
+    subjectId: import("fumadb/schema").Column<"string", string, string>;
+    consentId: import("fumadb/schema").Column<"string", string | null, string | null>;
+    actionType: import("fumadb/schema").Column<"string", string, string>;
+    details: import("fumadb/schema").Column<"json", unknown, unknown>;
+    createdAt: import("fumadb/schema").Column<"timestamp", Date | null, Date>;
+}, {}>;
+export declare const consentRecordSchema: z.ZodObject<{
+    id: z.ZodString;
+    subjectId: z.ZodString;
+    consentId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    actionType: z.ZodString;
+    details: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+    createdAt: z.ZodPrefault<z.ZodDate>;
+}, z.core.$strip>;
+export type ConsentRecord = z.infer<typeof consentRecordSchema>;
+//# sourceMappingURL=consent-record.d.ts.map

package/dist/v2/db/schema/1.0.0/consent-record.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"consent-record.d.ts","sourceRoot":"","sources":["../../../../../src/v2/db/schema/1.0.0/consent-record.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,kBAAkB;;;;;;;MAO7B,CAAC;AAEH,eAAO,MAAM,mBAAmB;;;;;;;iBAO9B,CAAC;AAEH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC"}

package/dist/v2/db/schema/1.0.0/consent.d.ts

@@ -0,0 +1,42 @@
+import { z } from 'zod';
+export declare const consentTable: import("fumadb/schema").Table<{
+    id: import("fumadb/schema").IdColumn<"varchar(255)", string, string>;
+    subjectId: import("fumadb/schema").Column<"string", string, string>;
+    domainId: import("fumadb/schema").Column<"string", string, string>;
+    policyId: import("fumadb/schema").Column<"string", string | null, string | null>;
+    purposeIds: import("fumadb/schema").Column<"json", unknown, unknown>;
+    metadata: import("fumadb/schema").Column<"json", unknown, unknown>;
+    ipAddress: import("fumadb/schema").Column<"string", string | null, string | null>;
+    userAgent: import("fumadb/schema").Column<"string", string | null, string | null>;
+    status: import("fumadb/schema").Column<"string", string | null, string>;
+    withdrawalReason: import("fumadb/schema").Column<"string", string | null, string | null>;
+    givenAt: import("fumadb/schema").Column<"timestamp", Date | null, Date>;
+    validUntil: import("fumadb/schema").Column<"timestamp", Date | null, Date | null>;
+    isActive: import("fumadb/schema").Column<"bool", boolean | null, boolean>;
+}, {}>;
+export declare const consentStatusSchema: z.ZodEnum<{
+    active: "active";
+    withdrawn: "withdrawn";
+    expired: "expired";
+}>;
+export declare const consentSchema: z.ZodObject<{
+    id: z.ZodString;
+    subjectId: z.ZodString;
+    domainId: z.ZodString;
+    purposeIds: z.ZodArray<z.ZodString>;
+    metadata: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+    policyId: z.ZodOptional<z.ZodString>;
+    ipAddress: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    userAgent: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    status: z.ZodPrefault<z.ZodEnum<{
+        active: "active";
+        withdrawn: "withdrawn";
+        expired: "expired";
+    }>>;
+    withdrawalReason: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    givenAt: z.ZodPrefault<z.ZodDate>;
+    validUntil: z.ZodOptional<z.ZodNullable<z.ZodDate>>;
+    isActive: z.ZodPrefault<z.ZodBoolean>;
+}, z.core.$strip>;
+export type Consent = z.infer<typeof consentSchema>;
+//# sourceMappingURL=consent.d.ts.map

package/dist/v2/db/schema/1.0.0/consent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"consent.d.ts","sourceRoot":"","sources":["../../../../../src/v2/db/schema/1.0.0/consent.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,YAAY;;;;;;;;;;;;;;MAcvB,CAAC;AAEH,eAAO,MAAM,mBAAmB;;;;EAA6C,CAAC;AAE9E,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;iBAcxB,CAAC;AAEH,MAAM,MAAM,OAAO,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC"}

package/dist/v2/db/schema/1.0.0/domain.d.ts

@@ -0,0 +1,23 @@
+import { z } from 'zod';
+export declare const domainTable: import("fumadb/schema").Table<{
+    id: import("fumadb/schema").IdColumn<"varchar(255)", string, string>;
+    name: import("fumadb/schema").Column<"string", string, string>;
+    description: import("fumadb/schema").Column<"string", string | null, string | null>;
+    allowedOrigins: import("fumadb/schema").Column<"json", unknown, unknown>;
+    isVerified: import("fumadb/schema").Column<"bool", boolean | null, boolean>;
+    isActive: import("fumadb/schema").Column<"bool", boolean | null, boolean>;
+    createdAt: import("fumadb/schema").Column<"timestamp", Date | null, Date>;
+    updatedAt: import("fumadb/schema").Column<"timestamp", Date | null, Date>;
+}, {}>;
+export declare const domainSchema: z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    description: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    allowedOrigins: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+    isVerified: z.ZodPrefault<z.ZodBoolean>;
+    isActive: z.ZodPrefault<z.ZodBoolean>;
+    createdAt: z.ZodPrefault<z.ZodDate>;
+    updatedAt: z.ZodPrefault<z.ZodDate>;
+}, z.core.$strip>;
+export type Domain = z.infer<typeof domainSchema>;
+//# sourceMappingURL=domain.d.ts.map

package/dist/v2/db/schema/1.0.0/domain.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"domain.d.ts","sourceRoot":"","sources":["../../../../../src/v2/db/schema/1.0.0/domain.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,WAAW;;;;;;;;;MAStB,CAAC;AAEH,eAAO,MAAM,YAAY;;;;;;;;;iBASvB,CAAC;AAEH,MAAM,MAAM,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAC"}