@c15t/backend 1.0.0 → 1.1.0-canary.0

package/dist/core.d.ts

@@ -1,6 +1,13 @@
 import type { C15TContext, C15TOptions, C15TPlugin } from './types';
-import { type SDKResult, type SDKResultAsync } from './pkgs/results';
-import type { Route } from './routes/types';
+import { router } from './router';
+/**
+ * Type representing an API route
+ */
+export type Route = {
+    path: string;
+    method: string;
+    description?: string;
+};
 /**
  * Interface representing a configured c15t consent management instance.
  *
@@ -11,8 +18,7 @@ import type { Route } from './routes/types';
  * management system. It includes methods for handling requests, accessing API
  * endpoints, and managing the system's configuration.
  *
- * All asynchronous operations return {@link SDKResultAsync} types for
- * consistent error handling across the system.
+ * All asynchronous operations return Promises for consistent error handling.
  *
  * @example
  * ```typescript
@@ -30,95 +36,544 @@ export interface C15TInstance<PluginTypes extends C15TPlugin[] = C15TPlugin[]> {
      * Processes incoming HTTP requests and routes them to appropriate handlers.
      *
      * @param request - The incoming web request
-     * @returns A Promise resolving to a Result containing the HTTP response
-     *
-     * @throws Never - All errors are captured in the Result type
+     * @returns A Promise containing the HTTP response
      *
      * @example
      * ```typescript
-     * const result = await instance.handler(request);
-     * result.match(
-     *   response => sendResponse(response),
-     *   error => handleError(error)
-     * );
+     * try {
+     *   const response = await instance.handler(request);
+     *   sendResponse(response);
+     * } catch (error) {
+     *   handleError(error);
+     * }
      * ```
      */
-    handler: (request: Request) => Promise<SDKResultAsync<Response>>;
-    /**
-     * Retrieves available API endpoints and their configurations.
-     *
-     * @returns A Promise resolving to a Result containing the available API endpoints
-     *
-     * @throws Never - All errors are captured in the Result type
-     *
-     * @example
-     * ```typescript
-     * const endpoints = await instance.getApi();
-     * endpoints.map(
-     *   apis => console.log('Available endpoints:', apis),
-     *   error => console.error('Failed to get endpoints:', error)
-     * );
-     * ```
-     */
-    getApi: () => Promise<SDKResultAsync<Route[]>>;
+    handler: (request: Request) => Promise<Response>;
     /**
      * The configuration options used for this instance.
      */
     options: C15TOptions<PluginTypes>;
     /**
-     * Access to the underlying context as a Result type.
+     * Access to the underlying context.
+     */
+    $context: Promise<C15TContext>;
+    /**
+     * Access to the router for direct usage.
+     */
+    router: typeof router;
+    /**
+     * Generates and returns the OpenAPI specification as a JSON object.
      *
-     * @remarks
-     * The context is wrapped in a Result type to ensure error handling
-     * consistency. Access should be handled using Result pattern methods.
+     * @returns A Promise containing the OpenAPI specification
      */
-    $context: Promise<SDKResult<C15TContext>>;
+    getOpenAPISpec: () => Promise<Record<string, unknown>>;
+    /**
+     * Returns an HTML document with the API documentation UI.
+     *
+     * @returns An HTML string with the API reference UI
+     */
+    getDocsUI: () => string;
 }
 /**
  * Creates a new c15t consent management instance.
  *
- * @typeParam PluginTypes - Array of plugin types to be used in this instance
- * @typeParam ConfigOptions - Configuration options extending the base C15TOptions
- *
- * @param options - Configuration options for the consent management system
- * @returns A configured C15TInstance ready for use
- *
- * @remarks
- * This is the main factory function for creating c15t instances. It initializes
- * the consent management system with the provided configuration and sets up all
- * necessary components including:
- *
- * - Database adapters
- * - Plugin system
- * - Request handlers
- * - API endpoints
- * - CORS configuration
- *
- * All async operations use the Result pattern for error handling, ensuring
- * that errors are handled consistently throughout the system.
- *
- * @example
- * Basic initialization:
- * ```typescript
- * import { c15tInstance } from '@c15t/backend';
- *
- * const manager = c15tInstance({
- *   secret: process.env.SECRET_KEY,
- *   storage: memoryAdapter()
- * });
- * ```
- *
- * @example
- * Advanced initialization with type parameters:
- * ```typescript
- * type MyPlugins = [typeof geoPlugin, typeof analyticsPlugin];
- *
- * const c15t = c15tInstance<MyPlugins>({
- *   secret: process.env.SECRET_KEY,
- *   storage: kyselyAdapter(db),
- *   plugins: [geoPlugin(), analyticsPlugin()]
- * });
- * ```
+ * This version provides a unified handler that works with oRPC to handle requests.
  */
-export declare const c15tInstance: <PluginTypes extends C15TPlugin[] = C15TPlugin[]>(options: C15TOptions<PluginTypes>) => C15TInstance<PluginTypes>;
+export declare const c15tInstance: <PluginTypes extends C15TPlugin[] = C15TPlugin[]>(options: C15TOptions<PluginTypes>) => {
+    getOpenAPISpec: (() => Promise<Record<string, unknown>>) & {
+        cached?: Record<string, unknown>;
+    };
+    getDocsUI: () => string;
+    GET: (request: Request) => Promise<Response>;
+    POST: (request: Request) => Promise<Response>;
+    PUT: (request: Request) => Promise<Response>;
+    PATCH: (request: Request) => Promise<Response>;
+    DELETE: (request: Request) => Promise<Response>;
+    OPTIONS: (request: Request) => Promise<Response>;
+    HEAD: (request: Request) => Promise<Response>;
+    options: C15TOptions<PluginTypes>;
+    $context: Promise<C15TContext>;
+    router: {
+        consent: {
+            post: import("@orpc/server").Procedure<import("@orpc/server").MergedInitialContext<Record<never, never>, Record<never, never>, Record<never, never>>, Record<never, never>, 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_and_conditions", "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_and_conditions", "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_and_conditions"]>;
+                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_and_conditions";
+                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_and_conditions";
+                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_and_conditions", "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: "marketing_communications" | "age_verification" | "other";
+                domain: string;
+                subjectId?: string | undefined;
+                metadata?: Record<string, unknown> | undefined;
+                externalSubjectId?: string | undefined;
+                preferences?: Record<string, boolean> | undefined;
+            }, {
+                type: "marketing_communications" | "age_verification" | "other";
+                domain: string;
+                subjectId?: string | undefined;
+                metadata?: Record<string, unknown> | undefined;
+                externalSubjectId?: string | undefined;
+                preferences?: Record<string, boolean> | undefined;
+            }>]>, import("zod").ZodObject<{
+                id: import("zod").ZodString;
+                subjectId: import("zod").ZodOptional<import("zod").ZodString>;
+                externalSubjectId: import("zod").ZodOptional<import("zod").ZodString>;
+                domainId: import("zod").ZodString;
+                domain: import("zod").ZodString;
+                type: import("zod").ZodEnum<["cookie_banner", "privacy_policy", "dpa", "terms_and_conditions", "marketing_communications", "age_verification", "other"]>;
+                status: import("zod").ZodString;
+                recordId: import("zod").ZodString;
+                metadata: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+                givenAt: import("zod").ZodDate;
+            }, "strip", import("zod").ZodTypeAny, {
+                type: "cookie_banner" | "privacy_policy" | "dpa" | "terms_and_conditions" | "marketing_communications" | "age_verification" | "other";
+                status: string;
+                id: string;
+                domain: string;
+                domainId: string;
+                givenAt: Date;
+                recordId: string;
+                subjectId?: string | undefined;
+                metadata?: Record<string, unknown> | undefined;
+                externalSubjectId?: string | undefined;
+            }, {
+                type: "cookie_banner" | "privacy_policy" | "dpa" | "terms_and_conditions" | "marketing_communications" | "age_verification" | "other";
+                status: string;
+                id: string;
+                domain: string;
+                domainId: string;
+                givenAt: Date;
+                recordId: string;
+                subjectId?: string | undefined;
+                metadata?: Record<string, unknown> | undefined;
+                externalSubjectId?: string | undefined;
+            }>, import("@orpc/contract").MergedErrorMap<Record<never, never>, import("@orpc/contract").MergedErrorMap<Record<never, never>, {
+                INPUT_VALIDATION_FAILED: {
+                    status: number;
+                    message: string;
+                    data: import("zod").ZodObject<{
+                        formErrors: import("zod").ZodArray<import("zod").ZodString, "many">;
+                        fieldErrors: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodArray<import("zod").ZodString, "many">>;
+                    }, "strip", import("zod").ZodTypeAny, {
+                        formErrors: string[];
+                        fieldErrors: Record<string, string[]>;
+                    }, {
+                        formErrors: string[];
+                        fieldErrors: Record<string, string[]>;
+                    }>;
+                };
+                SUBJECT_CREATION_FAILED: {
+                    status: number;
+                    message: string;
+                    data: import("zod").ZodObject<{
+                        subjectId: import("zod").ZodOptional<import("zod").ZodString>;
+                        externalSubjectId: import("zod").ZodOptional<import("zod").ZodString>;
+                    }, "strip", import("zod").ZodTypeAny, {
+                        subjectId?: string | undefined;
+                        externalSubjectId?: string | undefined;
+                    }, {
+                        subjectId?: string | undefined;
+                        externalSubjectId?: string | undefined;
+                    }>;
+                };
+                DOMAIN_CREATION_FAILED: {
+                    status: number;
+                    message: string;
+                    data: import("zod").ZodObject<{
+                        domain: import("zod").ZodString;
+                    }, "strip", import("zod").ZodTypeAny, {
+                        domain: string;
+                    }, {
+                        domain: string;
+                    }>;
+                };
+                POLICY_NOT_FOUND: {
+                    status: number;
+                    message: string;
+                    data: import("zod").ZodObject<{
+                        policyId: import("zod").ZodString;
+                        type: import("zod").ZodString;
+                    }, "strip", import("zod").ZodTypeAny, {
+                        type: string;
+                        policyId: string;
+                    }, {
+                        type: string;
+                        policyId: string;
+                    }>;
+                };
+                POLICY_INACTIVE: {
+                    status: number;
+                    message: string;
+                    data: import("zod").ZodObject<{
+                        policyId: import("zod").ZodString;
+                        type: import("zod").ZodString;
+                    }, "strip", import("zod").ZodTypeAny, {
+                        type: string;
+                        policyId: string;
+                    }, {
+                        type: string;
+                        policyId: string;
+                    }>;
+                };
+                POLICY_CREATION_FAILED: {
+                    status: number;
+                    message: string;
+                    data: import("zod").ZodObject<{
+                        type: import("zod").ZodString;
+                    }, "strip", import("zod").ZodTypeAny, {
+                        type: string;
+                    }, {
+                        type: string;
+                    }>;
+                };
+                PURPOSE_CREATION_FAILED: {
+                    status: number;
+                    message: string;
+                    data: import("zod").ZodObject<{
+                        purposeCode: import("zod").ZodString;
+                    }, "strip", import("zod").ZodTypeAny, {
+                        purposeCode: string;
+                    }, {
+                        purposeCode: string;
+                    }>;
+                };
+                CONSENT_CREATION_FAILED: {
+                    status: number;
+                    message: string;
+                    data: import("zod").ZodObject<{
+                        subjectId: import("zod").ZodString;
+                        domain: import("zod").ZodString;
+                    }, "strip", import("zod").ZodTypeAny, {
+                        subjectId: string;
+                        domain: string;
+                    }, {
+                        subjectId: string;
+                        domain: string;
+                    }>;
+                };
+            }>>, Record<never, never>>;
+            showBanner: import("@orpc/server").Procedure<import("@orpc/server").MergedInitialContext<Record<never, never>, Record<never, never>, Record<never, never>>, Record<never, never>, import("@orpc/contract").Schema<unknown, unknown>, import("zod").ZodObject<{
+                showConsentBanner: import("zod").ZodBoolean;
+                jurisdiction: import("zod").ZodObject<{
+                    code: import("zod").ZodEnum<["GDPR", "CH", "BR", "PIPEDA", "AU", "APPI", "PIPA", "NONE"]>;
+                    message: import("zod").ZodString;
+                }, "strip", import("zod").ZodTypeAny, {
+                    code: "GDPR" | "CH" | "BR" | "PIPEDA" | "AU" | "APPI" | "PIPA" | "NONE";
+                    message: string;
+                }, {
+                    code: "GDPR" | "CH" | "BR" | "PIPEDA" | "AU" | "APPI" | "PIPA" | "NONE";
+                    message: string;
+                }>;
+                location: import("zod").ZodObject<{
+                    countryCode: import("zod").ZodNullable<import("zod").ZodString>;
+                    regionCode: import("zod").ZodNullable<import("zod").ZodString>;
+                }, "strip", import("zod").ZodTypeAny, {
+                    countryCode: string | null;
+                    regionCode: string | null;
+                }, {
+                    countryCode: string | null;
+                    regionCode: string | null;
+                }>;
+            }, "strip", import("zod").ZodTypeAny, {
+                showConsentBanner: boolean;
+                jurisdiction: {
+                    code: "GDPR" | "CH" | "BR" | "PIPEDA" | "AU" | "APPI" | "PIPA" | "NONE";
+                    message: string;
+                };
+                location: {
+                    countryCode: string | null;
+                    regionCode: string | null;
+                };
+            }, {
+                showConsentBanner: boolean;
+                jurisdiction: {
+                    code: "GDPR" | "CH" | "BR" | "PIPEDA" | "AU" | "APPI" | "PIPA" | "NONE";
+                    message: string;
+                };
+                location: {
+                    countryCode: string | null;
+                    regionCode: string | null;
+                };
+            }>, import("@orpc/contract").MergedErrorMap<Record<never, never>, Record<never, never>>, Record<never, never>>;
+            verify: import("@orpc/server").Procedure<import("@orpc/server").MergedInitialContext<Record<never, never>, Record<never, never>, Record<never, never>>, Record<never, never>, import("zod").ZodObject<{
+                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_and_conditions", "marketing_communications", "age_verification", "other"]>;
+                policyId: import("zod").ZodOptional<import("zod").ZodString>;
+                preferences: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+            }, "strict", import("zod").ZodTypeAny, {
+                type: "cookie_banner" | "privacy_policy" | "dpa" | "terms_and_conditions" | "marketing_communications" | "age_verification" | "other";
+                domain: string;
+                subjectId?: string | undefined;
+                policyId?: string | undefined;
+                externalSubjectId?: string | undefined;
+                preferences?: string[] | undefined;
+            }, {
+                type: "cookie_banner" | "privacy_policy" | "dpa" | "terms_and_conditions" | "marketing_communications" | "age_verification" | "other";
+                domain: string;
+                subjectId?: string | undefined;
+                policyId?: string | undefined;
+                externalSubjectId?: string | undefined;
+                preferences?: string[] | undefined;
+            }>, import("zod").ZodObject<{
+                isValid: import("zod").ZodBoolean;
+                reasons: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>;
+                consent: import("zod").ZodOptional<import("zod").ZodObject<{
+                    id: import("zod").ZodString;
+                    purposeIds: import("zod").ZodArray<import("zod").ZodString, "many">;
+                }, "passthrough", import("zod").ZodTypeAny, import("zod").objectOutputType<{
+                    id: import("zod").ZodString;
+                    purposeIds: import("zod").ZodArray<import("zod").ZodString, "many">;
+                }, import("zod").ZodTypeAny, "passthrough">, import("zod").objectInputType<{
+                    id: import("zod").ZodString;
+                    purposeIds: import("zod").ZodArray<import("zod").ZodString, "many">;
+                }, import("zod").ZodTypeAny, "passthrough">>>;
+            }, "strip", import("zod").ZodTypeAny, {
+                isValid: boolean;
+                consent?: import("zod").objectOutputType<{
+                    id: import("zod").ZodString;
+                    purposeIds: import("zod").ZodArray<import("zod").ZodString, "many">;
+                }, import("zod").ZodTypeAny, "passthrough"> | undefined;
+                reasons?: string[] | undefined;
+            }, {
+                isValid: boolean;
+                consent?: import("zod").objectInputType<{
+                    id: import("zod").ZodString;
+                    purposeIds: import("zod").ZodArray<import("zod").ZodString, "many">;
+                }, import("zod").ZodTypeAny, "passthrough"> | undefined;
+                reasons?: string[] | undefined;
+            }>, import("@orpc/contract").MergedErrorMap<Record<never, never>, import("@orpc/contract").MergedErrorMap<Record<never, never>, {
+                INPUT_VALIDATION_FAILED: {
+                    status: number;
+                    message: string;
+                    data: import("zod").ZodObject<{
+                        formErrors: import("zod").ZodArray<import("zod").ZodString, "many">;
+                        fieldErrors: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString, "many">>>;
+                    }, "strip", import("zod").ZodTypeAny, {
+                        formErrors: string[];
+                        fieldErrors: Record<string, string[] | undefined>;
+                    }, {
+                        formErrors: string[];
+                        fieldErrors: Record<string, string[] | undefined>;
+                    }>;
+                };
+                SUBJECT_NOT_FOUND: {
+                    status: number;
+                    message: string;
+                    data: import("zod").ZodObject<{
+                        subjectId: import("zod").ZodOptional<import("zod").ZodString>;
+                        externalSubjectId: import("zod").ZodOptional<import("zod").ZodString>;
+                    }, "strip", import("zod").ZodTypeAny, {
+                        subjectId?: string | undefined;
+                        externalSubjectId?: string | undefined;
+                    }, {
+                        subjectId?: string | undefined;
+                        externalSubjectId?: string | undefined;
+                    }>;
+                };
+                DOMAIN_NOT_FOUND: {
+                    status: number;
+                    message: string;
+                    data: import("zod").ZodObject<{
+                        domain: import("zod").ZodString;
+                    }, "strip", import("zod").ZodTypeAny, {
+                        domain: string;
+                    }, {
+                        domain: string;
+                    }>;
+                };
+                POLICY_NOT_FOUND: {
+                    status: number;
+                    message: string;
+                    data: import("zod").ZodObject<{
+                        policyId: import("zod").ZodString;
+                        type: import("zod").ZodString;
+                    }, "strip", import("zod").ZodTypeAny, {
+                        type: string;
+                        policyId: string;
+                    }, {
+                        type: string;
+                        policyId: string;
+                    }>;
+                };
+                PURPOSES_NOT_FOUND: {
+                    status: number;
+                    message: string;
+                    data: import("zod").ZodObject<{
+                        preferences: import("zod").ZodArray<import("zod").ZodString, "many">;
+                        foundPurposes: import("zod").ZodArray<import("zod").ZodString, "many">;
+                    }, "strip", import("zod").ZodTypeAny, {
+                        preferences: string[];
+                        foundPurposes: string[];
+                    }, {
+                        preferences: string[];
+                        foundPurposes: string[];
+                    }>;
+                };
+                COOKIE_BANNER_PREFERENCES_REQUIRED: {
+                    status: number;
+                    message: string;
+                    data: import("zod").ZodObject<{
+                        type: import("zod").ZodLiteral<"cookie_banner">;
+                    }, "strip", import("zod").ZodTypeAny, {
+                        type: "cookie_banner";
+                    }, {
+                        type: "cookie_banner";
+                    }>;
+                };
+                NO_CONSENT_FOUND: {
+                    status: number;
+                    message: string;
+                    data: import("zod").ZodObject<{
+                        policyId: import("zod").ZodString;
+                        subjectId: import("zod").ZodString;
+                        domainId: import("zod").ZodString;
+                    }, "strip", import("zod").ZodTypeAny, {
+                        subjectId: string;
+                        domainId: string;
+                        policyId: string;
+                    }, {
+                        subjectId: string;
+                        domainId: string;
+                        policyId: string;
+                    }>;
+                };
+            }>>, Record<never, never>>;
+        };
+        meta: {
+            status: import("@orpc/server").Procedure<import("@orpc/server").MergedInitialContext<Record<never, never>, Record<never, never>, Record<never, never>>, Record<never, never>, import("@orpc/contract").Schema<unknown, unknown>, import("zod").ZodObject<{
+                status: import("zod").ZodEnum<["ok", "error"]>;
+                version: import("zod").ZodString;
+                timestamp: import("zod").ZodDate;
+                storage: import("zod").ZodObject<{
+                    type: import("zod").ZodString;
+                    available: import("zod").ZodBoolean;
+                }, "strip", import("zod").ZodTypeAny, {
+                    type: string;
+                    available: boolean;
+                }, {
+                    type: string;
+                    available: boolean;
+                }>;
+                client: import("zod").ZodObject<{
+                    ip: import("zod").ZodNullable<import("zod").ZodString>;
+                    userAgent: import("zod").ZodNullable<import("zod").ZodString>;
+                    region: import("zod").ZodObject<{
+                        countryCode: import("zod").ZodNullable<import("zod").ZodString>;
+                        regionCode: import("zod").ZodNullable<import("zod").ZodString>;
+                    }, "strip", import("zod").ZodTypeAny, {
+                        countryCode: string | null;
+                        regionCode: string | null;
+                    }, {
+                        countryCode: string | null;
+                        regionCode: string | null;
+                    }>;
+                }, "strip", import("zod").ZodTypeAny, {
+                    userAgent: string | null;
+                    ip: string | null;
+                    region: {
+                        countryCode: string | null;
+                        regionCode: string | null;
+                    };
+                }, {
+                    userAgent: string | null;
+                    ip: string | null;
+                    region: {
+                        countryCode: string | null;
+                        regionCode: string | null;
+                    };
+                }>;
+            }, "strip", import("zod").ZodTypeAny, {
+                storage: {
+                    type: string;
+                    available: boolean;
+                };
+                status: "error" | "ok";
+                version: string;
+                timestamp: Date;
+                client: {
+                    userAgent: string | null;
+                    ip: string | null;
+                    region: {
+                        countryCode: string | null;
+                        regionCode: string | null;
+                    };
+                };
+            }, {
+                storage: {
+                    type: string;
+                    available: boolean;
+                };
+                status: "error" | "ok";
+                version: string;
+                timestamp: Date;
+                client: {
+                    userAgent: string | null;
+                    ip: string | null;
+                    region: {
+                        countryCode: string | null;
+                        regionCode: string | null;
+                    };
+                };
+            }>, import("@orpc/contract").MergedErrorMap<Record<never, never>, Record<never, never>>, Record<never, never>>;
+        };
+    };
+    handler: (request: Request) => Promise<Response>;
+};
+export type { C15TPlugin, C15TOptions, C15TContext };
+export type { ContractsInputs, ContractsOutputs } from './contracts';
 //# sourceMappingURL=core.d.ts.map

package/dist/core.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"core.d.ts","sourceRoot":"","sources":["../src/core.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAGpE,OAAO,EAEN,KAAK,SAAS,EACd,KAAK,cAAc,EAGnB,MAAM,gBAAgB,CAAC;AAExB,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,gBAAgB,CAAC;AAE5C;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,MAAM,WAAW,YAAY,CAAC,WAAW,SAAS,UAAU,EAAE,GAAG,UAAU,EAAE;IAC5E;;;;;;;;;;;;;;;;OAgBG;IACH,OAAO,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,OAAO,CAAC,cAAc,CAAC,QAAQ,CAAC,CAAC,CAAC;IAEjE;;;;;;;;;;;;;;;OAeG;IACH,MAAM,EAAE,MAAM,OAAO,CAAC,cAAc,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC;IAE/C;;OAEG;IACH,OAAO,EAAE,WAAW,CAAC,WAAW,CAAC,CAAC;IAElC;;;;;;OAMG;IACH,QAAQ,EAAE,OAAO,CAAC,SAAS,CAAC,WAAW,CAAC,CAAC,CAAC;CAC1C;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACH,eAAO,MAAM,YAAY,GAAI,WAAW,SAAS,UAAU,EAAE,GAAG,UAAU,EAAE,EAC3E,SAAS,WAAW,CAAC,WAAW,CAAC,KAC/B,YAAY,CAAC,WAAW,CAkG1B,CAAC"}
+{"version":3,"file":"core.d.ts","sourceRoot":"","sources":["../src/core.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,WAAW,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAMpE,OAAO,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAClC;;GAEG;AACH,MAAM,MAAM,KAAK,GAAG;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,WAAW,CAAC,EAAE,MAAM,CAAC;CACrB,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,MAAM,WAAW,YAAY,CAAC,WAAW,SAAS,UAAU,EAAE,GAAG,UAAU,EAAE;IAC5E;;;;;;;;;;;;;;;OAeG;IACH,OAAO,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,OAAO,CAAC,QAAQ,CAAC,CAAC;IAEjD;;OAEG;IACH,OAAO,EAAE,WAAW,CAAC,WAAW,CAAC,CAAC;IAElC;;OAEG;IACH,QAAQ,EAAE,OAAO,CAAC,WAAW,CAAC,CAAC;IAE/B;;OAEG;IACH,MAAM,EAAE,OAAO,MAAM,CAAC;IAEtB;;;;OAIG;IACH,cAAc,EAAE,MAAM,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IAEvD;;;;OAIG;IACH,SAAS,EAAE,MAAM,MAAM,CAAC;CACxB;AAkBD;;;;GAIG;AACH,eAAO,MAAM,YAAY,GAAI,WAAW,SAAS,UAAU,EAAE,GAAG,UAAU,EAAE,EAC3E,SAAS,WAAW,CAAC,WAAW,CAAC;2BAiKpB,OAAO,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;iBACnC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;;;mBA6MI,OAAO;oBAAP,OAAO;mBAAP,OAAO;qBAAP,OAAO;sBAAP,OAAO;uBAAP,OAAO;oBAAP,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;uBAxCZ,OAAO,KAAG,OAAO,CAAC,QAAQ,CAAC;CAgF3D,CAAC;AAEF,YAAY,EAAE,UAAU,EAAE,WAAW,EAAE,WAAW,EAAE,CAAC;AACrD,YAAY,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC"}