@c15t/node-sdk 1.8.0 → 2.0.0-rc.0

package/dist/endpoints/consent.d.ts

@@ -0,0 +1,17 @@
+import type { CheckConsentOutput, CheckConsentQuery } from '@c15t/schema/types';
+import type { FetcherContext } from '../fetcher';
+import type { FetchOptions, ResponseContext } from '../types';
+/**
+ * API endpoint path for consent check
+ */
+export declare const CONSENT_CHECK_PATH = "/consents/check";
+/**
+ * Check consent status for an external ID
+ *
+ * @param context - Fetcher context
+ * @param query - Query parameters (externalId required)
+ * @param options - Optional fetch options
+ * @returns Consent check response
+ */
+export declare function checkConsent(context: FetcherContext, query: CheckConsentQuery, options?: FetchOptions<CheckConsentOutput, never, CheckConsentQuery>): Promise<ResponseContext<CheckConsentOutput>>;
+//# sourceMappingURL=consent.d.ts.map

package/dist/endpoints/consent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"consent.d.ts","sourceRoot":"","sources":["../../src/endpoints/consent.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AAChF,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAEjD,OAAO,KAAK,EAAE,YAAY,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAE9D;;GAEG;AACH,eAAO,MAAM,kBAAkB,oBAAoB,CAAC;AAEpD;;;;;;;GAOG;AACH,wBAAsB,YAAY,CACjC,OAAO,EAAE,cAAc,EACvB,KAAK,EAAE,iBAAiB,EACxB,OAAO,CAAC,EAAE,YAAY,CAAC,kBAAkB,EAAE,KAAK,EAAE,iBAAiB,CAAC,GAClE,OAAO,CAAC,eAAe,CAAC,kBAAkB,CAAC,CAAC,CAU9C"}

package/dist/endpoints/index.d.ts

@@ -0,0 +1,5 @@
+export { CONSENT_CHECK_PATH, checkConsent } from './consent';
+export { INIT_PATH, init } from './init';
+export { STATUS_PATH, status } from './status';
+export { createSubject, getSubject, listSubjects, patchSubject, SUBJECTS_PATH, } from './subjects';
+//# sourceMappingURL=index.d.ts.map

package/dist/endpoints/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/endpoints/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AAC7D,OAAO,EAAE,SAAS,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AACzC,OAAO,EAAE,WAAW,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAC/C,OAAO,EACN,aAAa,EACb,UAAU,EACV,YAAY,EACZ,YAAY,EACZ,aAAa,GACb,MAAM,YAAY,CAAC"}

package/dist/endpoints/init.d.ts

@@ -0,0 +1,16 @@
+import type { InitOutput } from '@c15t/schema/types';
+import type { FetcherContext } from '../fetcher';
+import type { FetchOptions, ResponseContext } from '../types';
+/**
+ * API endpoint path for init
+ */
+export declare const INIT_PATH = "/init";
+/**
+ * Initialize consent manager
+ *
+ * @param context - Fetcher context
+ * @param options - Optional fetch options
+ * @returns Init response with jurisdiction, location, translations, branding
+ */
+export declare function init(context: FetcherContext, options?: FetchOptions<InitOutput>): Promise<ResponseContext<InitOutput>>;
+//# sourceMappingURL=init.d.ts.map

package/dist/endpoints/init.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"init.d.ts","sourceRoot":"","sources":["../../src/endpoints/init.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AACrD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAEjD,OAAO,KAAK,EAAE,YAAY,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAE9D;;GAEG;AACH,eAAO,MAAM,SAAS,UAAU,CAAC;AAEjC;;;;;;GAMG;AACH,wBAAsB,IAAI,CACzB,OAAO,EAAE,cAAc,EACvB,OAAO,CAAC,EAAE,YAAY,CAAC,UAAU,CAAC,GAChC,OAAO,CAAC,eAAe,CAAC,UAAU,CAAC,CAAC,CAKtC"}

package/dist/endpoints/status.d.ts

@@ -0,0 +1,16 @@
+import type { StatusOutput } from '@c15t/schema/types';
+import type { FetcherContext } from '../fetcher';
+import type { FetchOptions, ResponseContext } from '../types';
+/**
+ * API endpoint path for status
+ */
+export declare const STATUS_PATH = "/status";
+/**
+ * Get API status
+ *
+ * @param context - Fetcher context
+ * @param options - Optional fetch options
+ * @returns Status response
+ */
+export declare function status(context: FetcherContext, options?: FetchOptions<StatusOutput>): Promise<ResponseContext<StatusOutput>>;
+//# sourceMappingURL=status.d.ts.map

package/dist/endpoints/status.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"status.d.ts","sourceRoot":"","sources":["../../src/endpoints/status.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AACvD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAEjD,OAAO,KAAK,EAAE,YAAY,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAE9D;;GAEG;AACH,eAAO,MAAM,WAAW,YAAY,CAAC;AAErC;;;;;;GAMG;AACH,wBAAsB,MAAM,CAC3B,OAAO,EAAE,cAAc,EACvB,OAAO,CAAC,EAAE,YAAY,CAAC,YAAY,CAAC,GAClC,OAAO,CAAC,eAAe,CAAC,YAAY,CAAC,CAAC,CAKxC"}

package/dist/endpoints/subjects.d.ts

@@ -0,0 +1,46 @@
+import type { GetSubjectOutput, GetSubjectQuery, ListSubjectsOutput, ListSubjectsQuery, PatchSubjectFullInput, PatchSubjectOutput, PostSubjectInput, PostSubjectOutput } from '@c15t/schema/types';
+import type { FetcherContext } from '../fetcher';
+import type { FetchOptions, ResponseContext } from '../types';
+/**
+ * API endpoint paths for subjects
+ */
+export declare const SUBJECTS_PATH = "/subjects";
+/**
+ * Create a new subject with consent preferences
+ *
+ * @param context - Fetcher context
+ * @param input - Subject creation input
+ * @param options - Optional fetch options
+ * @returns Created subject response
+ */
+export declare function createSubject(context: FetcherContext, input: PostSubjectInput, options?: FetchOptions<PostSubjectOutput, PostSubjectInput>): Promise<ResponseContext<PostSubjectOutput>>;
+/**
+ * Get a subject by ID
+ *
+ * @param context - Fetcher context
+ * @param id - Subject ID
+ * @param query - Optional query parameters
+ * @param options - Optional fetch options
+ * @returns Subject data response
+ */
+export declare function getSubject(context: FetcherContext, id: string, query?: GetSubjectQuery, options?: FetchOptions<GetSubjectOutput, never, GetSubjectQuery>): Promise<ResponseContext<GetSubjectOutput>>;
+/**
+ * Update a subject (link external ID or update preferences)
+ *
+ * @param context - Fetcher context
+ * @param id - Subject ID
+ * @param input - Patch input with externalId or other fields
+ * @param options - Optional fetch options
+ * @returns Updated subject response
+ */
+export declare function patchSubject(context: FetcherContext, id: string, input: Omit<PatchSubjectFullInput, 'id'>, options?: FetchOptions<PatchSubjectOutput, Omit<PatchSubjectFullInput, 'id'>>): Promise<ResponseContext<PatchSubjectOutput>>;
+/**
+ * List subjects with optional filtering
+ *
+ * @param context - Fetcher context
+ * @param query - Query parameters for filtering
+ * @param options - Optional fetch options
+ * @returns List of subjects
+ */
+export declare function listSubjects(context: FetcherContext, query?: ListSubjectsQuery, options?: FetchOptions<ListSubjectsOutput, never, ListSubjectsQuery>): Promise<ResponseContext<ListSubjectsOutput>>;
+//# sourceMappingURL=subjects.d.ts.map

package/dist/endpoints/subjects.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"subjects.d.ts","sourceRoot":"","sources":["../../src/endpoints/subjects.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACX,gBAAgB,EAChB,eAAe,EACf,kBAAkB,EAClB,iBAAiB,EACjB,qBAAqB,EACrB,kBAAkB,EAClB,gBAAgB,EAChB,iBAAiB,EACjB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAEjD,OAAO,KAAK,EAAE,YAAY,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAE9D;;GAEG;AACH,eAAO,MAAM,aAAa,cAAc,CAAC;AAEzC;;;;;;;GAOG;AACH,wBAAsB,aAAa,CAClC,OAAO,EAAE,cAAc,EACvB,KAAK,EAAE,gBAAgB,EACvB,OAAO,CAAC,EAAE,YAAY,CAAC,iBAAiB,EAAE,gBAAgB,CAAC,GACzD,OAAO,CAAC,eAAe,CAAC,iBAAiB,CAAC,CAAC,CAM7C;AAED;;;;;;;;GAQG;AACH,wBAAsB,UAAU,CAC/B,OAAO,EAAE,cAAc,EACvB,EAAE,EAAE,MAAM,EACV,KAAK,CAAC,EAAE,eAAe,EACvB,OAAO,CAAC,EAAE,YAAY,CAAC,gBAAgB,EAAE,KAAK,EAAE,eAAe,CAAC,GAC9D,OAAO,CAAC,eAAe,CAAC,gBAAgB,CAAC,CAAC,CAU5C;AAED;;;;;;;;GAQG;AACH,wBAAsB,YAAY,CACjC,OAAO,EAAE,cAAc,EACvB,EAAE,EAAE,MAAM,EACV,KAAK,EAAE,IAAI,CAAC,qBAAqB,EAAE,IAAI,CAAC,EACxC,OAAO,CAAC,EAAE,YAAY,CAAC,kBAAkB,EAAE,IAAI,CAAC,qBAAqB,EAAE,IAAI,CAAC,CAAC,GAC3E,OAAO,CAAC,eAAe,CAAC,kBAAkB,CAAC,CAAC,CAU9C;AAED;;;;;;;GAOG;AACH,wBAAsB,YAAY,CACjC,OAAO,EAAE,cAAc,EACvB,KAAK,CAAC,EAAE,iBAAiB,EACzB,OAAO,CAAC,EAAE,YAAY,CAAC,kBAAkB,EAAE,KAAK,EAAE,iBAAiB,CAAC,GAClE,OAAO,CAAC,eAAe,CAAC,kBAAkB,CAAC,CAAC,CAU9C"}

package/dist/error.d.ts

@@ -0,0 +1,86 @@
+/**
+ * C15TError - Custom error class for typed error handling
+ *
+ * @example
+ * ```typescript
+ * import { C15TError } from '@c15t/node-sdk';
+ *
+ * try {
+ *   const subject = (await client.getSubject('sub_123')).unwrap();
+ * } catch (error) {
+ *   if (error instanceof C15TError) {
+ *     console.log(error.status); // 404
+ *     console.log(error.code);   // 'NOT_FOUND'
+ *     console.log(error.details);
+ *   }
+ * }
+ * ```
+ */
+export declare class C15TError extends Error {
+    /**
+     * HTTP status code of the error response
+     */
+    readonly status: number;
+    /**
+     * Error code for programmatic error identification
+     */
+    readonly code?: string;
+    /**
+     * Additional error details
+     */
+    readonly details?: Record<string, unknown> | null;
+    /**
+     * Original cause of the error (if any)
+     */
+    readonly cause?: unknown;
+    constructor(options: {
+        message: string;
+        status: number;
+        code?: string;
+        details?: Record<string, unknown> | null;
+        cause?: unknown;
+    });
+    /**
+     * Check if the error is a specific HTTP status code
+     */
+    isStatus(status: number): boolean;
+    /**
+     * Check if the error is a not found error (404)
+     */
+    isNotFound(): boolean;
+    /**
+     * Check if the error is a validation error (400)
+     */
+    isValidationError(): boolean;
+    /**
+     * Check if the error is an authentication error (401)
+     */
+    isUnauthorized(): boolean;
+    /**
+     * Check if the error is a forbidden error (403)
+     */
+    isForbidden(): boolean;
+    /**
+     * Check if the error is a server error (5xx)
+     */
+    isServerError(): boolean;
+    /**
+     * Check if the error is a network error
+     */
+    isNetworkError(): boolean;
+    /**
+     * Convert error to a plain object for serialization
+     */
+    toJSON(): {
+        name: string;
+        message: string;
+        status: number;
+        code?: string;
+        details?: Record<string, unknown> | null;
+    };
+}
+/**
+ * Type guard to check if an error is a C15TError
+ */
+export declare function isC15TError(error: unknown): error is C15TError;
+//# sourceMappingURL=error.d.ts.map

package/dist/error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"error.d.ts","sourceRoot":"","sources":["../src/error.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH,qBAAa,SAAU,SAAQ,KAAK;IACnC;;OAEG;IACH,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IAExB;;OAEG;IACH,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IAEvB;;OAEG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;IAElD;;OAEG;IACH,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,CAAC;gBAEb,OAAO,EAAE;QACpB,OAAO,EAAE,MAAM,CAAC;QAChB,MAAM,EAAE,MAAM,CAAC;QACf,IAAI,CAAC,EAAE,MAAM,CAAC;QACd,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;QACzC,KAAK,CAAC,EAAE,OAAO,CAAC;KAChB;IAcD;;OAEG;IACH,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO;IAIjC;;OAEG;IACH,UAAU,IAAI,OAAO;IAIrB;;OAEG;IACH,iBAAiB,IAAI,OAAO;IAI5B;;OAEG;IACH,cAAc,IAAI,OAAO;IAIzB;;OAEG;IACH,WAAW,IAAI,OAAO;IAItB;;OAEG;IACH,aAAa,IAAI,OAAO;IAIxB;;OAEG;IACH,cAAc,IAAI,OAAO;IAIzB;;OAEG;IACH,MAAM,IAAI;QACT,IAAI,EAAE,MAAM,CAAC;QACb,OAAO,EAAE,MAAM,CAAC;QAChB,MAAM,EAAE,MAAM,CAAC;QACf,IAAI,CAAC,EAAE,MAAM,CAAC;QACd,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;KACzC;CASD;AAED;;GAEG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,SAAS,CAE9D"}

package/dist/fetcher.d.ts

@@ -0,0 +1,38 @@
+import type { FetchOptions, ResponseContext, RetryConfig } from './types';
+/**
+ * Default retry configuration
+ */
+export declare const DEFAULT_RETRY_CONFIG: RetryConfig;
+/**
+ * Default timeout in milliseconds (30 seconds)
+ */
+export declare const DEFAULT_TIMEOUT_MS = 30000;
+/**
+ * Base context for fetcher operations
+ */
+export interface FetcherContext {
+    baseUrl: string;
+    headers: Record<string, string>;
+    retryConfig: RetryConfig;
+    debug: boolean;
+    timeout: number;
+}
+/**
+ * Creates a response context object with Result-like helper methods
+ */
+export declare function createResponseContext<T>(isSuccess: boolean, data?: T | null, error?: {
+    message: string;
+    status: number;
+    code?: string;
+    cause?: unknown;
+    details?: Record<string, unknown> | null;
+} | null, response?: Response | null): ResponseContext<T>;
+/**
+ * Resolves a URL path against the base URL
+ */
+export declare function resolveUrl(baseUrl: string, path: string): string;
+/**
+ * Makes an HTTP request with retry logic
+ */
+export declare function fetcher<ResponseType, BodyType = unknown, QueryType = unknown>(context: FetcherContext, path: string, options?: FetchOptions<ResponseType, BodyType, QueryType>): Promise<ResponseContext<ResponseType>>;
+//# sourceMappingURL=fetcher.d.ts.map

package/dist/fetcher.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fetcher.d.ts","sourceRoot":"","sources":["../src/fetcher.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,eAAe,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAE1E;;GAEG;AACH,eAAO,MAAM,oBAAoB,EAAE,WAOlC,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,kBAAkB,QAAQ,CAAC;AAExC;;GAEG;AACH,MAAM,WAAW,cAAc;IAC9B,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAChC,WAAW,EAAE,WAAW,CAAC;IACzB,KAAK,EAAE,OAAO,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;CAChB;AAsCD;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,CAAC,EACtC,SAAS,EAAE,OAAO,EAClB,IAAI,GAAE,CAAC,GAAG,IAAW,EACrB,KAAK,GAAE;IACN,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;CACzC,GAAG,IAAW,EACf,QAAQ,GAAE,QAAQ,GAAG,IAAW,GAC9B,eAAe,CAAC,CAAC,CAAC,CA2DpB;AAED;;GAEG;AACH,wBAAgB,UAAU,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAMhE;AAED;;GAEG;AACH,wBAAsB,OAAO,CAC5B,YAAY,EACZ,QAAQ,GAAG,OAAO,EAClB,SAAS,GAAG,OAAO,EAEnB,OAAO,EAAE,cAAc,EACvB,IAAI,EAAE,MAAM,EACZ,OAAO,CAAC,EAAE,YAAY,CAAC,YAAY,EAAE,QAAQ,EAAE,SAAS,CAAC,GACvD,OAAO,CAAC,eAAe,CAAC,YAAY,CAAC,CAAC,CAkRxC"}

package/dist/index.cjs

@@ -24,30 +24,397 @@ var __webpack_require__ = {};
 var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
-    c15tClient: ()=>c15tClient
+    resolveUrl: ()=>resolveUrl,
+    c15tClient: ()=>c15tClient,
+    C15TClient: ()=>C15TClient,
+    createResponseContext: ()=>createResponseContext,
+    fetcher: ()=>fetcher,
+    isC15TError: ()=>isC15TError,
+    C15TError: ()=>C15TError
 });
-const contracts_namespaceObject = require("@c15t/backend/contracts");
-const client_namespaceObject = require("@orpc/client");
-const fetch_namespaceObject = require("@orpc/openapi-client/fetch");
-function c15tClient(options) {
-    const authHeaders = options.token ? {
-        Authorization: `Bearer ${options.token}`
-    } : {};
-    const baseUrl = new URL(options.baseUrl);
-    if (options.prefix) baseUrl.pathname = options.prefix;
-    const link = new fetch_namespaceObject.OpenAPILink(contracts_namespaceObject.contracts, {
-        url: baseUrl.toString(),
-        headers: {
-            ...authHeaders,
-            ...options.headers
+class C15TError extends Error {
+    status;
+    code;
+    details;
+    cause;
+    constructor(options){
+        super(options.message);
+        this.name = 'C15TError';
+        this.status = options.status;
+        this.code = options.code;
+        this.details = options.details;
+        this.cause = options.cause;
+        if (Error.captureStackTrace) Error.captureStackTrace(this, C15TError);
+    }
+    isStatus(status) {
+        return this.status === status;
+    }
+    isNotFound() {
+        return 404 === this.status || 'NOT_FOUND' === this.code;
+    }
+    isValidationError() {
+        return 400 === this.status || 'VALIDATION_ERROR' === this.code;
+    }
+    isUnauthorized() {
+        return 401 === this.status || 'UNAUTHORIZED' === this.code;
+    }
+    isForbidden() {
+        return 403 === this.status || 'FORBIDDEN' === this.code;
+    }
+    isServerError() {
+        return this.status >= 500 && this.status < 600;
+    }
+    isNetworkError() {
+        return 0 === this.status || 'NETWORK_ERROR' === this.code;
+    }
+    toJSON() {
+        return {
+            name: this.name,
+            message: this.message,
+            status: this.status,
+            code: this.code,
+            details: this.details
+        };
+    }
+}
+function isC15TError(error) {
+    return error instanceof C15TError;
+}
+const DEFAULT_RETRY_CONFIG = {
+    maxRetries: 3,
+    initialDelayMs: 100,
+    backoffFactor: 2,
+    retryableStatusCodes: [
+        500,
+        502,
+        503,
+        504
+    ],
+    nonRetryableStatusCodes: [
+        400,
+        401,
+        403,
+        404
+    ],
+    retryOnNetworkError: true
+};
+const DEFAULT_TIMEOUT_MS = 30000;
+function debugLog(debug, method, path, durationMs, status) {
+    if (!debug) return;
+    const timestamp = new Date().toISOString();
+    console.log(`[c15t] ${timestamp} ${method} ${path} (${durationMs}ms) -> ${status}`);
+}
+const delay = (ms)=>new Promise((resolve)=>setTimeout(resolve, ms));
+function generateUUID() {
+    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c)=>{
+        const r = 16 * Math.random() | 0;
+        const v = 'x' === c ? r : 0x3 & r | 0x8;
+        return v.toString(16);
+    });
+}
+function createResponseContext(isSuccess, data = null, error = null, response = null) {
+    return {
+        data,
+        error,
+        ok: isSuccess,
+        response,
+        unwrap () {
+            if (!isSuccess || null === data) throw new C15TError({
+                message: error?.message || 'Request failed',
+                status: error?.status || 0,
+                code: error?.code,
+                details: error?.details,
+                cause: error?.cause
+            });
+            return data;
+        },
+        unwrapOr (defaultValue) {
+            if (!isSuccess || null === data) return defaultValue;
+            return data;
+        },
+        expect (message) {
+            if (!isSuccess || null === data) throw new C15TError({
+                message,
+                status: error?.status || 0,
+                code: error?.code,
+                details: error?.details,
+                cause: error?.cause
+            });
+            return data;
+        },
+        map (fn) {
+            if (!isSuccess || null === data) return createResponseContext(false, null, error, response);
+            return createResponseContext(true, fn(data), null, response);
+        }
+    };
+}
+function resolveUrl(baseUrl, path) {
+    const cleanBase = baseUrl.endsWith('/') ? baseUrl.slice(0, -1) : baseUrl;
+    const cleanPath = path.startsWith('/') ? path.slice(1) : path;
+    return `${cleanBase}/${cleanPath}`;
+}
+async function fetcher(context, path, options) {
+    const finalRetryConfig = {
+        ...DEFAULT_RETRY_CONFIG,
+        ...context.retryConfig,
+        ...options?.retryConfig || {}
+    };
+    const { maxRetries = 3, initialDelayMs = 100, backoffFactor = 2, retryableStatusCodes = [
+        500,
+        502,
+        503,
+        504
+    ], nonRetryableStatusCodes = [
+        400,
+        401,
+        403,
+        404
+    ], retryOnNetworkError = true } = finalRetryConfig;
+    let attemptsMade = 0;
+    let currentDelay = initialDelayMs;
+    let lastErrorResponse = null;
+    while(attemptsMade <= maxRetries){
+        const requestId = generateUUID();
+        const resolvedUrl = resolveUrl(context.baseUrl, path);
+        const url = new URL(resolvedUrl);
+        if (options?.query) {
+            for (const [key, value] of Object.entries(options.query))if (null != value) url.searchParams.append(key, String(value));
+        }
+        const timeoutMs = options?.timeout ?? context.timeout;
+        const controller = new AbortController();
+        let timeoutId;
+        if (timeoutMs > 0) timeoutId = setTimeout(()=>controller.abort(), timeoutMs);
+        const requestOptions = {
+            method: options?.method || 'GET',
+            headers: {
+                'Content-Type': 'application/json',
+                ...context.headers,
+                'X-Request-ID': requestId,
+                ...options?.headers
+            },
+            signal: controller.signal
+        };
+        if (options?.body && 'GET' !== requestOptions.method) requestOptions.body = JSON.stringify(options.body);
+        const startTime = Date.now();
+        try {
+            const response = await fetch(url.toString(), requestOptions);
+            if (timeoutId) clearTimeout(timeoutId);
+            const durationMs = Date.now() - startTime;
+            let data = null;
+            let parseError = null;
+            try {
+                const contentType = response.headers.get('content-type');
+                if (contentType?.includes('application/json') && 204 !== response.status && '0' !== response.headers.get('content-length')) data = await response.json();
+                else if (204 === response.status) data = null;
+            } catch (err) {
+                parseError = err;
+            }
+            if (parseError) {
+                const errorResponse = createResponseContext(false, null, {
+                    message: 'Failed to parse response',
+                    status: response.status,
+                    code: 'PARSE_ERROR',
+                    cause: parseError
+                }, response);
+                options?.onError?.(errorResponse, path);
+                if (options?.throw) throw new Error('Failed to parse response');
+                return errorResponse;
+            }
+            const isSuccess = response.status >= 200 && response.status < 300;
+            if (isSuccess) {
+                debugLog(context.debug, requestOptions.method || 'GET', path, durationMs, response.status);
+                const successResponse = createResponseContext(true, data, null, response);
+                options?.onSuccess?.(successResponse);
+                return successResponse;
+            }
+            const errorData = data;
+            const errorResponse = createResponseContext(false, null, {
+                message: errorData?.message || `Request failed with status ${response.status}`,
+                status: response.status,
+                code: errorData?.code || 'API_ERROR',
+                details: errorData?.details || null
+            }, response);
+            lastErrorResponse = errorResponse;
+            let shouldRetryThisRequest = false;
+            shouldRetryThisRequest = nonRetryableStatusCodes.includes(response.status) ? false : retryableStatusCodes.includes(response.status);
+            if (!shouldRetryThisRequest || attemptsMade >= maxRetries) {
+                debugLog(context.debug, requestOptions.method || 'GET', path, durationMs, response.status);
+                options?.onError?.(errorResponse, path);
+                if (options?.throw) throw new Error(errorResponse.error?.message || 'Request failed');
+                return errorResponse;
+            }
+            attemptsMade++;
+            await delay(currentDelay);
+            currentDelay *= backoffFactor;
+        } catch (fetchError) {
+            if (timeoutId) clearTimeout(timeoutId);
+            if (fetchError instanceof Error && 'Failed to parse response' === fetchError.message) throw fetchError;
+            const isAbortError = fetchError instanceof Error && 'AbortError' === fetchError.name;
+            const isNetworkError = !(fetchError instanceof Response);
+            const errorResponse = createResponseContext(false, null, {
+                message: isAbortError ? `Request timed out after ${timeoutMs}ms` : fetchError instanceof Error ? fetchError.message : String(fetchError),
+                status: 0,
+                code: isAbortError ? 'TIMEOUT' : 'NETWORK_ERROR',
+                cause: fetchError
+            }, null);
+            lastErrorResponse = errorResponse;
+            const shouldRetryThisRequest = isNetworkError && retryOnNetworkError;
+            if (!shouldRetryThisRequest || attemptsMade >= maxRetries) {
+                debugLog(context.debug, requestOptions.method || 'GET', path, Date.now() - startTime, 'ERROR');
+                options?.onError?.(errorResponse, path);
+                if (options?.throw) throw fetchError;
+                return errorResponse;
+            }
+            attemptsMade++;
+            await delay(currentDelay);
+            currentDelay *= backoffFactor;
         }
+    }
+    const maxRetriesErrorResponse = lastErrorResponse || createResponseContext(false, null, {
+        message: `Request failed after ${maxRetries} retries`,
+        status: 0,
+        code: 'MAX_RETRIES_EXCEEDED'
+    }, null);
+    options?.onError?.(maxRetriesErrorResponse, path);
+    if (options?.throw) throw new Error(`Request failed after ${maxRetries} retries`);
+    return maxRetriesErrorResponse;
+}
+const CONSENT_CHECK_PATH = '/consents/check';
+async function checkConsent(context, query, options) {
+    return fetcher(context, CONSENT_CHECK_PATH, {
+        method: 'GET',
+        query,
+        ...options
+    });
+}
+const INIT_PATH = '/init';
+async function init(context, options) {
+    return fetcher(context, INIT_PATH, {
+        method: 'GET',
+        ...options
     });
-    return (0, client_namespaceObject.createORPCClient)(link);
 }
+const STATUS_PATH = '/status';
+async function status_status(context, options) {
+    return fetcher(context, STATUS_PATH, {
+        method: 'GET',
+        ...options
+    });
+}
+const SUBJECTS_PATH = '/subjects';
+async function createSubject(context, input, options) {
+    return fetcher(context, SUBJECTS_PATH, {
+        method: 'POST',
+        body: input,
+        ...options
+    });
+}
+async function getSubject(context, id, query, options) {
+    return fetcher(context, `${SUBJECTS_PATH}/${id}`, {
+        method: 'GET',
+        query,
+        ...options
+    });
+}
+async function patchSubject(context, id, input, options) {
+    return fetcher(context, `${SUBJECTS_PATH}/${id}`, {
+        method: 'PATCH',
+        body: input,
+        ...options
+    });
+}
+async function listSubjects(context, query, options) {
+    return fetcher(context, SUBJECTS_PATH, {
+        method: 'GET',
+        query,
+        ...options
+    });
+}
+class C15TClient {
+    context;
+    constructor(options = {}){
+        const baseUrlString = options.baseUrl || ('undefined' != typeof process ? process.env?.C15T_API_URL : void 0);
+        if (!baseUrlString) throw new TypeError('baseUrl is required. Provide it in options or set C15T_API_URL environment variable.');
+        const baseUrl = new URL(baseUrlString);
+        if (options.prefix) baseUrl.pathname = options.prefix;
+        const token = options.token || ('undefined' != typeof process ? process.env?.C15T_API_TOKEN : void 0);
+        const authHeaders = token ? {
+            Authorization: `Bearer ${token}`
+        } : {};
+        const retryConfig = {
+            ...DEFAULT_RETRY_CONFIG,
+            ...options.retryConfig
+        };
+        const debug = options.debug ?? ('undefined' != typeof process ? process.env?.C15T_DEBUG === 'true' : false);
+        const timeout = options.timeout ?? DEFAULT_TIMEOUT_MS;
+        this.context = {
+            baseUrl: baseUrl.toString(),
+            headers: {
+                ...authHeaders,
+                ...options.headers
+            },
+            retryConfig,
+            debug,
+            timeout
+        };
+    }
+    async status(options) {
+        return status_status(this.context, options);
+    }
+    async init(options) {
+        return init(this.context, options);
+    }
+    async createSubject(input, options) {
+        return createSubject(this.context, input, options);
+    }
+    async getSubject(id, query, options) {
+        return getSubject(this.context, id, query, options);
+    }
+    async patchSubject(id, input, options) {
+        return patchSubject(this.context, id, input, options);
+    }
+    async listSubjects(query, options) {
+        return listSubjects(this.context, query, options);
+    }
+    async checkConsent(query, options) {
+        return checkConsent(this.context, query, options);
+    }
+    async $fetch(path, options) {
+        return fetcher(this.context, path, options);
+    }
+    consent = {
+        check: (query, options)=>this.checkConsent(query, options)
+    };
+    subjects = {
+        create: (input, options)=>this.createSubject(input, options),
+        get: (id, query, options)=>this.getSubject(id, query, options),
+        patch: (id, input, options)=>this.patchSubject(id, input, options),
+        list: (query, options)=>this.listSubjects(query, options)
+    };
+    meta = {
+        status: (options)=>this.status(options),
+        init: (options)=>this.init(options)
+    };
+}
+function c15tClient(options) {
+    return new C15TClient(options);
+}
+exports.C15TClient = __webpack_exports__.C15TClient;
+exports.C15TError = __webpack_exports__.C15TError;
 exports.c15tClient = __webpack_exports__.c15tClient;
-for(var __webpack_i__ in __webpack_exports__)if (-1 === [
-    "c15tClient"
-].indexOf(__webpack_i__)) exports[__webpack_i__] = __webpack_exports__[__webpack_i__];
+exports.createResponseContext = __webpack_exports__.createResponseContext;
+exports.fetcher = __webpack_exports__.fetcher;
+exports.isC15TError = __webpack_exports__.isC15TError;
+exports.resolveUrl = __webpack_exports__.resolveUrl;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "C15TClient",
+    "C15TError",
+    "c15tClient",
+    "createResponseContext",
+    "fetcher",
+    "isC15TError",
+    "resolveUrl"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
 Object.defineProperty(exports, '__esModule', {
     value: true
 });