@c15t/backend 0.0.1-rc.10

package/dist/api/routes/get-consent-policy.d.ts

@@ -0,0 +1,164 @@
+import { z } from 'zod';
+export interface GetPolicyResponse {
+    success: boolean;
+    data: {
+        policy: {
+            id: string;
+            domain: string;
+            version: string;
+            content: string;
+            availablePreferences?: Record<string, unknown>;
+            createdAt: string;
+        };
+        subjectConsentStatus?: {
+            hasConsent: boolean;
+            currentPreferences: Record<string, string | null> | null;
+            consentedAt: string | null;
+            needsRenewal: boolean;
+            identifiedBy: string | null;
+        };
+    };
+}
+/**
+ * Endpoint for retrieving consent policy information.
+ *
+ * This endpoint allows clients to retrieve the consent policy for a domain.
+ * It supports retrieving the latest policy or a specific version.
+ * It can also return personalized policy information if subject identifiers are provided.
+ *
+ * @endpoint GET /consent/policy
+ * @requestExample
+ * ```
+ * // Basic policy request
+ * GET /api/consent/policy?domain=example.com
+ * ```
+ *
+ * @requestExample
+ * ```
+ * // Specific version
+ * GET /api/consent/policy?domain=example.com&version=1.2
+ * ```
+ *
+ * @requestExample
+ * ```
+ * // With subject context
+ * GET /api/consent/policy?domain=example.com&subjectId=550e8400-e29b-41d4-a716-446655440000
+ * ```
+ *
+ * @responseExample
+ * ```json
+ * {
+ *   "success": true,
+ *   "data": {
+ *     "policy": {
+ *       "id": 1,
+ *       "domain": "example.com",
+ *       "version": "1.0",
+ *       "content": {
+ *         "title": "Privacy Policy",
+ *         "description": "How we use your data",
+ *         "lastUpdated": "2023-04-01"
+ *       },
+ *       "availablePreferences": {
+ *         "marketing": {
+ *           "title": "Marketing",
+ *           "description": "Allow us to send you marketing communications",
+ *           "default": false
+ *         },
+ *         "analytics": {
+ *           "title": "Analytics",
+ *           "description": "Allow us to collect usage data to improve our service",
+ *           "default": true
+ *         }
+ *       },
+ *       "createdAt": "2023-04-01T12:34:56.789Z"
+ *     },
+ *     "subjectConsentStatus": {
+ *       "hasConsent": true,
+ *       "currentPreferences": {
+ *         "marketing": null,
+ *         "analytics": "2023-04-02T10:30:00.000Z"
+ *       },
+ *       "consentedAt": "2023-04-02T10:30:00.000Z",
+ *       "needsRenewal": false
+ *     }
+ *   }
+ * }
+ * ```
+ *
+ * @returns {Object} Result of getting policy
+ * @returns {boolean} success - Whether the request was successful
+ * @returns {Object} data - The policy data
+ * @returns {Object} data.policy - The consent policy information
+ * @returns {Object} [data.subjectConsentStatus] - Subject's consent status if subject identifiers were provided
+ *
+ * @throws {C15TError} BAD_REQUEST - When request parameters are invalid
+ * @throws {C15TError} NOT_FOUND - When the domain or policy version doesn't exist
+ */
+export declare const getConsentPolicy: {
+    <C extends [import("better-call").InputContext<"/consent/policy", {
+        method: "GET";
+        query: z.ZodObject<z.objectUtil.extendShape<{
+            domain: z.ZodString;
+            version: z.ZodOptional<z.ZodString>;
+            includePreferences: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        }, {
+            subjectId: z.ZodOptional<z.ZodString>;
+            externalId: z.ZodOptional<z.ZodString>;
+            ipAddress: z.ZodOptional<z.ZodString>;
+        }>, "strip", z.ZodTypeAny, {
+            domain: string;
+            includePreferences: boolean;
+            subjectId?: string | undefined;
+            ipAddress?: string | undefined;
+            version?: string | undefined;
+            externalId?: string | undefined;
+        }, {
+            domain: string;
+            subjectId?: string | undefined;
+            ipAddress?: string | undefined;
+            version?: string | undefined;
+            externalId?: string | undefined;
+            includePreferences?: boolean | undefined;
+        }>;
+    } & {
+        use: any[];
+    }>]>(...inputCtx: C): Promise<C extends [{
+        asResponse: true;
+    }] ? Response : C extends [{
+        returnHeaders: true;
+    }] ? {
+        headers: Headers;
+        response: GetPolicyResponse;
+    } : GetPolicyResponse>;
+    options: {
+        method: "GET";
+        query: z.ZodObject<z.objectUtil.extendShape<{
+            domain: z.ZodString;
+            version: z.ZodOptional<z.ZodString>;
+            includePreferences: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        }, {
+            subjectId: z.ZodOptional<z.ZodString>;
+            externalId: z.ZodOptional<z.ZodString>;
+            ipAddress: z.ZodOptional<z.ZodString>;
+        }>, "strip", z.ZodTypeAny, {
+            domain: string;
+            includePreferences: boolean;
+            subjectId?: string | undefined;
+            ipAddress?: string | undefined;
+            version?: string | undefined;
+            externalId?: string | undefined;
+        }, {
+            domain: string;
+            subjectId?: string | undefined;
+            ipAddress?: string | undefined;
+            version?: string | undefined;
+            externalId?: string | undefined;
+            includePreferences?: boolean | undefined;
+        }>;
+    } & {
+        use: any[];
+    };
+    path: "/consent/policy";
+};
+//# sourceMappingURL=get-consent-policy.d.ts.map

package/dist/api/routes/get-consent-policy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-consent-policy.d.ts","sourceRoot":"","sources":["../../../src/api/routes/get-consent-policy.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAuBxB,MAAM,WAAW,iBAAiB;IACjC,OAAO,EAAE,OAAO,CAAC;IACjB,IAAI,EAAE;QACL,MAAM,EAAE;YACP,EAAE,EAAE,MAAM,CAAC;YACX,MAAM,EAAE,MAAM,CAAC;YACf,OAAO,EAAE,MAAM,CAAC;YAChB,OAAO,EAAE,MAAM,CAAC;YAChB,oBAAoB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;YAC/C,SAAS,EAAE,MAAM,CAAC;SAClB,CAAC;QACF,oBAAoB,CAAC,EAAE;YACtB,UAAU,EAAE,OAAO,CAAC;YACpB,kBAAkB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC,GAAG,IAAI,CAAC;YACzD,WAAW,EAAE,MAAM,GAAG,IAAI,CAAC;YAC3B,YAAY,EAAE,OAAO,CAAC;YACtB,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;SAC5B,CAAC;KACF,CAAC;CACF;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2EG;AACH,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA8M5B,CAAC"}

package/dist/api/routes/get-consent.d.ts

@@ -0,0 +1,148 @@
+import { z } from 'zod';
+export interface GetConsentResponse {
+    success: boolean;
+    data: {
+        hasActiveConsent: boolean;
+        records: Array<{
+            id: string;
+            subjectId: string;
+            domain: string;
+            status: string;
+            givenAt: string;
+            policyId: string;
+            preferences: Record<string, string | null>;
+        }>;
+        identifiedBy: string | null;
+    };
+}
+/**
+ * Endpoint for retrieving active consent records.
+ *
+ * This endpoint allows clients to retrieve a subject's active consent records by specifying:
+ * 1. The subject ID (internal UUID) and an optional domain
+ * 2. The external ID and an optional domain
+ * 3. The IP address and a required domain (since IP alone is too broad)
+ *
+ * @endpoint GET /consent/get
+ */
+export declare const getConsent: {
+    <C extends [import("better-call").InputContext<"/consent/get", {
+        method: "GET";
+        query: z.ZodDiscriminatedUnion<"identifierType", [z.ZodObject<{
+            subjectId: z.ZodString;
+            domain: z.ZodOptional<z.ZodString>;
+            identifierType: z.ZodLiteral<"subjectId">;
+        }, "strip", z.ZodTypeAny, {
+            subjectId: string;
+            identifierType: "subjectId";
+            domain?: string | undefined;
+        }, {
+            subjectId: string;
+            identifierType: "subjectId";
+            domain?: string | undefined;
+        }>, z.ZodObject<{
+            externalId: z.ZodString;
+            domain: z.ZodOptional<z.ZodString>;
+            identifierType: z.ZodLiteral<"externalId">;
+        }, "strip", z.ZodTypeAny, {
+            externalId: string;
+            identifierType: "externalId";
+            domain?: string | undefined;
+        }, {
+            externalId: string;
+            identifierType: "externalId";
+            domain?: string | undefined;
+        }>, z.ZodObject<{
+            ipAddress: z.ZodString;
+            domain: z.ZodString;
+            identifierType: z.ZodLiteral<"ipAddress">;
+        }, "strip", z.ZodTypeAny, {
+            ipAddress: string;
+            domain: string;
+            identifierType: "ipAddress";
+        }, {
+            ipAddress: string;
+            domain: string;
+            identifierType: "ipAddress";
+        }>]>;
+    } & {
+        use: any[];
+    }>]>(...inputCtx: C): Promise<C extends [{
+        asResponse: true;
+    }] ? Response : C extends [{
+        returnHeaders: true;
+    }] ? {
+        headers: Headers;
+        response: {
+            success: boolean;
+            data: {
+                hasActiveConsent: boolean;
+                records: {
+                    id: string;
+                    subjectId: string;
+                    domain: string;
+                    status: string;
+                    givenAt: string;
+                }[];
+                identifiedBy: "subjectId" | "ipAddress" | "externalId";
+            };
+        };
+    } : {
+        success: boolean;
+        data: {
+            hasActiveConsent: boolean;
+            records: {
+                id: string;
+                subjectId: string;
+                domain: string;
+                status: string;
+                givenAt: string;
+            }[];
+            identifiedBy: "subjectId" | "ipAddress" | "externalId";
+        };
+    }>;
+    options: {
+        method: "GET";
+        query: z.ZodDiscriminatedUnion<"identifierType", [z.ZodObject<{
+            subjectId: z.ZodString;
+            domain: z.ZodOptional<z.ZodString>;
+            identifierType: z.ZodLiteral<"subjectId">;
+        }, "strip", z.ZodTypeAny, {
+            subjectId: string;
+            identifierType: "subjectId";
+            domain?: string | undefined;
+        }, {
+            subjectId: string;
+            identifierType: "subjectId";
+            domain?: string | undefined;
+        }>, z.ZodObject<{
+            externalId: z.ZodString;
+            domain: z.ZodOptional<z.ZodString>;
+            identifierType: z.ZodLiteral<"externalId">;
+        }, "strip", z.ZodTypeAny, {
+            externalId: string;
+            identifierType: "externalId";
+            domain?: string | undefined;
+        }, {
+            externalId: string;
+            identifierType: "externalId";
+            domain?: string | undefined;
+        }>, z.ZodObject<{
+            ipAddress: z.ZodString;
+            domain: z.ZodString;
+            identifierType: z.ZodLiteral<"ipAddress">;
+        }, "strip", z.ZodTypeAny, {
+            ipAddress: string;
+            domain: string;
+            identifierType: "ipAddress";
+        }, {
+            ipAddress: string;
+            domain: string;
+            identifierType: "ipAddress";
+        }>]>;
+    } & {
+        use: any[];
+    };
+    path: "/consent/get";
+};
+//# sourceMappingURL=get-consent.d.ts.map

package/dist/api/routes/get-consent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-consent.d.ts","sourceRoot":"","sources":["../../../src/api/routes/get-consent.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAgCxB,MAAM,WAAW,kBAAkB;IAClC,OAAO,EAAE,OAAO,CAAC;IACjB,IAAI,EAAE;QACL,gBAAgB,EAAE,OAAO,CAAC;QAC1B,OAAO,EAAE,KAAK,CAAC;YACd,EAAE,EAAE,MAAM,CAAC;YACX,SAAS,EAAE,MAAM,CAAC;YAClB,MAAM,EAAE,MAAM,CAAC;YACf,MAAM,EAAE,MAAM,CAAC;YACf,OAAO,EAAE,MAAM,CAAC;YAChB,QAAQ,EAAE,MAAM,CAAC;YACjB,WAAW,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC,CAAC;SAC3C,CAAC,CAAC;QACH,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;KAC5B,CAAC;CACF;AAED;;;;;;;;;GASG;AACH,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBA+Ff,MAAM;+BACC,MAAM;4BACT,MAAM;4BACN,MAAM;6BACL,MAAM;;;;;;;;;;oBAJX,MAAM;2BACC,MAAM;wBACT,MAAM;wBACN,MAAM;yBACL,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAuElB,CAAC"}

package/dist/api/routes/index.d.ts

@@ -0,0 +1,339 @@
+export * from './error';
+export * from './ok';
+export declare const baseEndpoints: {
+    setConsent: {
+        <C extends [import("better-call").InputContext<"/consent/set", {
+            method: "POST";
+            body: import("zod").ZodDiscriminatedUnion<"type", [import("zod").ZodObject<import("zod").objectUtil.extendShape<{
+                subjectId: import("zod").ZodOptional<import("zod").ZodString>;
+                externalSubjectId: import("zod").ZodOptional<import("zod").ZodString>;
+                domain: import("zod").ZodString;
+                type: import("zod").ZodEnum<["cookie_banner", "privacy_policy", "dpa", "terms_of_service", "marketing_communications", "age_verification", "other"]>;
+                metadata: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+            }, {
+                type: import("zod").ZodLiteral<"cookie_banner">;
+                preferences: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodBoolean>;
+            }>, "strip", import("zod").ZodTypeAny, {
+                type: "cookie_banner";
+                domain: string;
+                preferences: Record<string, boolean>;
+                subjectId?: string | undefined;
+                metadata?: Record<string, unknown> | undefined;
+                externalSubjectId?: string | undefined;
+            }, {
+                type: "cookie_banner";
+                domain: string;
+                preferences: Record<string, boolean>;
+                subjectId?: string | undefined;
+                metadata?: Record<string, unknown> | undefined;
+                externalSubjectId?: string | undefined;
+            }>, import("zod").ZodObject<import("zod").objectUtil.extendShape<{
+                subjectId: import("zod").ZodOptional<import("zod").ZodString>;
+                externalSubjectId: import("zod").ZodOptional<import("zod").ZodString>;
+                domain: import("zod").ZodString;
+                type: import("zod").ZodEnum<["cookie_banner", "privacy_policy", "dpa", "terms_of_service", "marketing_communications", "age_verification", "other"]>;
+                metadata: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+            }, {
+                type: import("zod").ZodEnum<["privacy_policy", "dpa", "terms_of_service"]>;
+                policyId: import("zod").ZodOptional<import("zod").ZodString>;
+                preferences: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodBoolean>>;
+            }>, "strip", import("zod").ZodTypeAny, {
+                type: "privacy_policy" | "dpa" | "terms_of_service";
+                domain: string;
+                subjectId?: string | undefined;
+                metadata?: Record<string, unknown> | undefined;
+                policyId?: string | undefined;
+                externalSubjectId?: string | undefined;
+                preferences?: Record<string, boolean> | undefined;
+            }, {
+                type: "privacy_policy" | "dpa" | "terms_of_service";
+                domain: string;
+                subjectId?: string | undefined;
+                metadata?: Record<string, unknown> | undefined;
+                policyId?: string | undefined;
+                externalSubjectId?: string | undefined;
+                preferences?: Record<string, boolean> | undefined;
+            }>, import("zod").ZodObject<import("zod").objectUtil.extendShape<{
+                subjectId: import("zod").ZodOptional<import("zod").ZodString>;
+                externalSubjectId: import("zod").ZodOptional<import("zod").ZodString>;
+                domain: import("zod").ZodString;
+                type: import("zod").ZodEnum<["cookie_banner", "privacy_policy", "dpa", "terms_of_service", "marketing_communications", "age_verification", "other"]>;
+                metadata: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+            }, {
+                type: import("zod").ZodEnum<["marketing_communications", "age_verification", "other"]>;
+                preferences: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodBoolean>>;
+            }>, "strip", import("zod").ZodTypeAny, {
+                type: "other" | "marketing_communications" | "age_verification";
+                domain: string;
+                subjectId?: string | undefined;
+                metadata?: Record<string, unknown> | undefined;
+                externalSubjectId?: string | undefined;
+                preferences?: Record<string, boolean> | undefined;
+            }, {
+                type: "other" | "marketing_communications" | "age_verification";
+                domain: string;
+                subjectId?: string | undefined;
+                metadata?: Record<string, unknown> | undefined;
+                externalSubjectId?: string | undefined;
+                preferences?: Record<string, boolean> | undefined;
+            }>]>;
+        } & {
+            use: any[];
+        }>]>(...inputCtx: C): Promise<C extends [{
+            asResponse: true;
+        }] ? Response : C extends [{
+            returnHeaders: true;
+        }] ? {
+            headers: Headers;
+            response: {
+                id: string;
+                subjectId: string;
+                externalSubjectId: string | undefined;
+                domainId: string;
+                domain: string;
+                type: "other" | "cookie_banner" | "privacy_policy" | "dpa" | "terms_of_service" | "marketing_communications" | "age_verification";
+                status: "active" | "withdrawn" | "expired";
+                recordId: string;
+                metadata: Record<string, unknown> | undefined;
+                givenAt: string;
+            };
+        } : {
+            id: string;
+            subjectId: string;
+            externalSubjectId: string | undefined;
+            domainId: string;
+            domain: string;
+            type: "other" | "cookie_banner" | "privacy_policy" | "dpa" | "terms_of_service" | "marketing_communications" | "age_verification";
+            status: "active" | "withdrawn" | "expired";
+            recordId: string;
+            metadata: Record<string, unknown> | undefined;
+            givenAt: string;
+        }>;
+        options: {
+            method: "POST";
+            body: import("zod").ZodDiscriminatedUnion<"type", [import("zod").ZodObject<import("zod").objectUtil.extendShape<{
+                subjectId: import("zod").ZodOptional<import("zod").ZodString>;
+                externalSubjectId: import("zod").ZodOptional<import("zod").ZodString>;
+                domain: import("zod").ZodString;
+                type: import("zod").ZodEnum<["cookie_banner", "privacy_policy", "dpa", "terms_of_service", "marketing_communications", "age_verification", "other"]>;
+                metadata: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+            }, {
+                type: import("zod").ZodLiteral<"cookie_banner">;
+                preferences: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodBoolean>;
+            }>, "strip", import("zod").ZodTypeAny, {
+                type: "cookie_banner";
+                domain: string;
+                preferences: Record<string, boolean>;
+                subjectId?: string | undefined;
+                metadata?: Record<string, unknown> | undefined;
+                externalSubjectId?: string | undefined;
+            }, {
+                type: "cookie_banner";
+                domain: string;
+                preferences: Record<string, boolean>;
+                subjectId?: string | undefined;
+                metadata?: Record<string, unknown> | undefined;
+                externalSubjectId?: string | undefined;
+            }>, import("zod").ZodObject<import("zod").objectUtil.extendShape<{
+                subjectId: import("zod").ZodOptional<import("zod").ZodString>;
+                externalSubjectId: import("zod").ZodOptional<import("zod").ZodString>;
+                domain: import("zod").ZodString;
+                type: import("zod").ZodEnum<["cookie_banner", "privacy_policy", "dpa", "terms_of_service", "marketing_communications", "age_verification", "other"]>;
+                metadata: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+            }, {
+                type: import("zod").ZodEnum<["privacy_policy", "dpa", "terms_of_service"]>;
+                policyId: import("zod").ZodOptional<import("zod").ZodString>;
+                preferences: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodBoolean>>;
+            }>, "strip", import("zod").ZodTypeAny, {
+                type: "privacy_policy" | "dpa" | "terms_of_service";
+                domain: string;
+                subjectId?: string | undefined;
+                metadata?: Record<string, unknown> | undefined;
+                policyId?: string | undefined;
+                externalSubjectId?: string | undefined;
+                preferences?: Record<string, boolean> | undefined;
+            }, {
+                type: "privacy_policy" | "dpa" | "terms_of_service";
+                domain: string;
+                subjectId?: string | undefined;
+                metadata?: Record<string, unknown> | undefined;
+                policyId?: string | undefined;
+                externalSubjectId?: string | undefined;
+                preferences?: Record<string, boolean> | undefined;
+            }>, import("zod").ZodObject<import("zod").objectUtil.extendShape<{
+                subjectId: import("zod").ZodOptional<import("zod").ZodString>;
+                externalSubjectId: import("zod").ZodOptional<import("zod").ZodString>;
+                domain: import("zod").ZodString;
+                type: import("zod").ZodEnum<["cookie_banner", "privacy_policy", "dpa", "terms_of_service", "marketing_communications", "age_verification", "other"]>;
+                metadata: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+            }, {
+                type: import("zod").ZodEnum<["marketing_communications", "age_verification", "other"]>;
+                preferences: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodBoolean>>;
+            }>, "strip", import("zod").ZodTypeAny, {
+                type: "other" | "marketing_communications" | "age_verification";
+                domain: string;
+                subjectId?: string | undefined;
+                metadata?: Record<string, unknown> | undefined;
+                externalSubjectId?: string | undefined;
+                preferences?: Record<string, boolean> | undefined;
+            }, {
+                type: "other" | "marketing_communications" | "age_verification";
+                domain: string;
+                subjectId?: string | undefined;
+                metadata?: Record<string, unknown> | undefined;
+                externalSubjectId?: string | undefined;
+                preferences?: Record<string, boolean> | undefined;
+            }>]>;
+        } & {
+            use: any[];
+        };
+        path: "/consent/set";
+    };
+    showConsentBanner: {
+        <C extends [(import("better-call").InputContext<"/show-consent-banner", {
+            method: "GET";
+            metadata: {
+                openapi: {
+                    responses: {
+                        '200': {
+                            description: string;
+                            content: {
+                                'application/json': {
+                                    schema: {
+                                        type: "object";
+                                        properties: {
+                                            showConsentBanner: {
+                                                type: string;
+                                            };
+                                            jurisdiction: {
+                                                type: string;
+                                                properties: {
+                                                    code: {
+                                                        type: string;
+                                                    };
+                                                    message: {
+                                                        type: string;
+                                                    };
+                                                };
+                                            };
+                                            location: {
+                                                type: string;
+                                                properties: {
+                                                    countryCode: {
+                                                        type: string;
+                                                    };
+                                                    regionCode: {
+                                                        type: string;
+                                                    };
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            };
+        } & {
+            use: any[];
+        }> | undefined)?]>(...inputCtx: C): Promise<C extends [{
+            asResponse: true;
+        }] ? Response : C extends [{
+            returnHeaders: true;
+        }] ? {
+            headers: Headers;
+            response: {
+                showConsentBanner: boolean;
+                jurisdiction: {
+                    code: string;
+                    message: string;
+                };
+                location: {
+                    countryCode: string | null | undefined;
+                    regionCode: string | null | undefined;
+                };
+            };
+        } : {
+            showConsentBanner: boolean;
+            jurisdiction: {
+                code: string;
+                message: string;
+            };
+            location: {
+                countryCode: string | null | undefined;
+                regionCode: string | null | undefined;
+            };
+        }>;
+        options: {
+            method: "GET";
+            metadata: {
+                openapi: {
+                    responses: {
+                        '200': {
+                            description: string;
+                            content: {
+                                'application/json': {
+                                    schema: {
+                                        type: "object";
+                                        properties: {
+                                            showConsentBanner: {
+                                                type: string;
+                                            };
+                                            jurisdiction: {
+                                                type: string;
+                                                properties: {
+                                                    code: {
+                                                        type: string;
+                                                    };
+                                                    message: {
+                                                        type: string;
+                                                    };
+                                                };
+                                            };
+                                            location: {
+                                                type: string;
+                                                properties: {
+                                                    countryCode: {
+                                                        type: string;
+                                                    };
+                                                    regionCode: {
+                                                        type: string;
+                                                    };
+                                                };
+                                            };
+                                        };
+                                    };
+                                };
+                            };
+                        };
+                    };
+                };
+            };
+        } & {
+            use: any[];
+        };
+        path: "/show-consent-banner";
+    };
+    status: {
+        <C extends [(import("better-call").InputContext<"/status", {
+            method: "GET";
+        } & {
+            use: any[];
+        }> | undefined)?]>(...inputCtx: C): Promise<C extends [{
+            asResponse: true;
+        }] ? Response : C extends [{
+            returnHeaders: true;
+        }] ? {
+            headers: Headers;
+            response: import("./status").StatusResponse;
+        } : import("./status").StatusResponse>;
+        options: {
+            method: "GET";
+        } & {
+            use: any[];
+        };
+        path: "/status";
+    };
+};
+//# sourceMappingURL=index.d.ts.map

package/dist/api/routes/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/api/routes/index.ts"],"names":[],"mappings":"AAIA,cAAc,SAAS,CAAC;AACxB,cAAc,MAAM,CAAC;AAErB,eAAO,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAIzB,CAAC"}