@c15t/node-sdk 3.0.0-alpha.2 → 3.0.0-alpha.4

package/dist/index.js

@@ -1,397 +1,1064 @@
-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;
+import { checkConsentQuerySchema, experimentSummaryQuerySchema, legalDocumentCurrentInputSchema, legalDocumentCurrentParamsSchema, listSubjectsQuerySchema, patchSubjectInputSchema, postSubjectInputSchema } from "@c15t/schema";
+import { POLICY_CONTRACT_HEADER, POLICY_CONTRACT_VERSION, brandingValues } from "@c15t/schema/types";
+import { C15tError, isStalePolicyReason } from "./160.js";
+const defineEndpoint = (endpoint)=>endpoint;
+const checkSchema = async (schema, value, prefix = [])=>{
+    const result = await schema['~standard'].validate(value);
+    return (result.issues ?? []).map((issue)=>({
+            message: issue.message,
+            path: [
+                ...prefix,
+                ...(issue.path ?? []).map((segment)=>'object' == typeof segment ? segment.key : segment)
+            ]
+        }));
+};
+const requireText = (value, path)=>'string' == typeof value && '' !== value.trim() ? [] : [
+        {
+            message: 'Expected a non-empty string.',
+            path
+        }
+    ];
+const requirePathSegment = (value, path)=>{
+    const issues = requireText(value, path);
+    if (issues.length > 0) return issues;
+    return '.' === value || '..' === value ? [
+        {
+            message: 'Expected an id, not a dot path segment.',
+            path
+        }
+    ] : [];
+};
+const optionalText = (value, path)=>void 0 === value ? [] : requireText(value, path);
+const checkTypeList = (value, path, { required })=>{
+    if (void 0 === value && !required) return [];
+    if (!Array.isArray(value) || required && 0 === value.length) return [
+        {
+            message: required ? 'Expected a non-empty array of policy types.' : 'Expected an array of policy types.',
+            path
+        }
+    ];
+    return value.flatMap((entry, index)=>'string' != typeof entry || '' === entry || entry.includes(',') ? [
+            {
+                message: 'Expected a policy type without commas.',
+                path: [
+                    ...path,
+                    index
+                ]
+            }
+        ] : []);
+};
+const ISO_DATE_OR_TIMESTAMP = /^\d{4}-\d{2}-\d{2}(?:T\d{2}:\d{2}(?::\d{2}(?:\.\d+)?)?(?:Z|[+-]\d{2}:\d{2}))?$/u;
+const toIsoString = (value)=>value instanceof Date ? value.toISOString() : value;
+const checkDateLike = (value, path, { required })=>{
+    if (void 0 === value && !required) return [];
+    if (value instanceof Date) return Number.isNaN(value.getTime()) ? [
+        {
+            message: 'Expected a valid Date.',
+            path
+        }
+    ] : [];
+    return 'string' == typeof value && ISO_DATE_OR_TIMESTAMP.test(value) && !Number.isNaN(Date.parse(value)) && new Date(value.slice(0, 10)).toISOString().slice(0, 10) === value.slice(0, 10) ? [] : [
+        {
+            message: 'Expected a Date or an ISO 8601 string.',
+            path
+        }
+    ];
+};
+const isObject = (value)=>'object' == typeof value && null !== value && !Array.isArray(value);
+const requireObject = (value, path)=>isObject(value) ? [] : [
+        {
+            message: 'Expected an object.',
+            path
+        }
+    ];
+class DecodeError extends Error {
+    name = 'DecodeError';
+}
+const asObject = (value, field)=>{
+    if (!isObject(value)) throw new DecodeError(`Expected ${field} to be an object.`);
+    return value;
+};
+const asArray = (value, field)=>{
+    if (!Array.isArray(value)) throw new DecodeError(`Expected ${field} to be an array.`);
+    return value;
+};
+const toDate = (value, field)=>{
+    if ('string' == typeof value || 'number' == typeof value) {
+        const date = new Date(value);
+        if (!Number.isNaN(date.getTime())) return date;
     }
-    isValidationError() {
-        return 400 === this.status || 'VALIDATION_ERROR' === this.code;
+    throw new DecodeError(`Expected ${field} to be a date.`);
+};
+const decodeConsentItem = (value, field)=>{
+    const item = asObject(value, field);
+    const decoded = {
+        ...item,
+        givenAt: toDate(item.givenAt, `${field}.givenAt`)
+    };
+    if (null === item.policyEffectiveDate) delete decoded.policyEffectiveDate;
+    else if (void 0 !== item.policyEffectiveDate) decoded.policyEffectiveDate = toDate(item.policyEffectiveDate, `${field}.policyEffectiveDate`);
+    return decoded;
+};
+const decodeConsents = (value, field)=>asArray(value, field).map((item, index)=>decodeConsentItem(item, `${field}[${index}]`));
+const NO_ISSUES = [];
+const noValidation = ()=>Promise.resolve(NO_ISSUES);
+const contract_status = defineEndpoint({
+    auth: 'none',
+    decode: (body)=>{
+        const value = asObject(body, 'body');
+        return {
+            ...value,
+            timestamp: toDate(value.timestamp, 'timestamp')
+        };
+    },
+    errorCodes: [
+        'SERVICE_UNAVAILABLE'
+    ],
+    idempotent: true,
+    method: 'GET',
+    name: 'status',
+    path: '/status',
+    prepare: (_input)=>({
+            params: {}
+        }),
+    validate: noValidation
+});
+const contract_init = defineEndpoint({
+    auth: 'none',
+    decode: (body)=>asObject(body, 'body'),
+    errorCodes: [],
+    idempotent: true,
+    method: 'GET',
+    name: 'init',
+    path: '/init',
+    prepare: (input)=>{
+        const headers = {};
+        if (input?.language !== void 0) headers['accept-language'] = input.language;
+        if (input?.country !== void 0) headers['x-c15t-country'] = input.country;
+        if (input?.region !== void 0) headers['x-c15t-region'] = input.region;
+        if (input?.gpc !== void 0) headers['x-c15t-gpc'] = input.gpc ? '1' : '0';
+        return {
+            headers,
+            params: {}
+        };
+    },
+    validate: (input)=>{
+        if (void 0 === input) return Promise.resolve(NO_ISSUES);
+        if (!isObject(input)) return Promise.resolve(requireObject(input, []));
+        const issues = [
+            ...optionalText(input.language, [
+                'language'
+            ]),
+            ...optionalText(input.country, [
+                'country'
+            ]),
+            ...optionalText(input.region, [
+                'region'
+            ]),
+            ...void 0 === input.gpc || 'boolean' == typeof input.gpc ? [] : [
+                {
+                    message: 'Expected a boolean.',
+                    path: [
+                        'gpc'
+                    ]
+                }
+            ]
+        ];
+        return Promise.resolve(issues);
     }
-    isUnauthorized() {
-        return 401 === this.status || 'UNAUTHORIZED' === this.code;
+});
+const manifest = defineEndpoint({
+    accepts: (code)=>code >= 200 && code < 300 || 304 === code,
+    auth: 'none',
+    decode: (body, response)=>{
+        const etag = response.headers.get('etag') ?? void 0;
+        if (304 === response.status) return {
+            etag,
+            status: 'not-modified'
+        };
+        const value = asObject(body, 'body');
+        if (2 !== value.schemaVersion || 'string' != typeof value.revision || !brandingValues.some((branding)=>branding === value.branding)) throw new DecodeError('Expected manifest schemaVersion 2, a string revision and a supported branding value.');
+        return {
+            etag,
+            manifest: value,
+            status: 'modified'
+        };
+    },
+    errorCodes: [],
+    idempotent: true,
+    method: 'GET',
+    name: 'manifest',
+    path: '/manifest',
+    prepare: (input)=>{
+        const headers = {};
+        if (input?.ifNoneMatch !== void 0) headers['if-none-match'] = input.ifNoneMatch;
+        return {
+            headers,
+            params: {},
+            query: {
+                language: input?.language
+            }
+        };
+    },
+    validate: (input)=>{
+        if (void 0 === input) return Promise.resolve(NO_ISSUES);
+        if (!isObject(input)) return Promise.resolve(requireObject(input, []));
+        return Promise.resolve([
+            ...optionalText(input.language, [
+                'language'
+            ]),
+            ...optionalText(input.ifNoneMatch, [
+                'ifNoneMatch'
+            ])
+        ]);
     }
-    isForbidden() {
-        return 403 === this.status || 'FORBIDDEN' === this.code;
+});
+const getSubject = defineEndpoint({
+    auth: 'none',
+    decode: (body)=>{
+        const value = asObject(body, 'body');
+        const subject = {
+            ...asObject(value.subject, 'subject')
+        };
+        if (null === subject.createdAt) delete subject.createdAt;
+        else if (void 0 !== subject.createdAt) subject.createdAt = toDate(subject.createdAt, 'subject.createdAt');
+        return {
+            ...value,
+            consents: decodeConsents(value.consents, 'consents'),
+            subject
+        };
+    },
+    errorCodes: [
+        'DATABASE_ERROR',
+        'NOT_FOUND'
+    ],
+    idempotent: true,
+    method: 'GET',
+    name: 'subjects.get',
+    path: '/subjects/:id',
+    prepare: (input)=>({
+            params: {
+                id: input.id
+            },
+            query: {
+                type: input.request?.types?.join(',')
+            }
+        }),
+    validate: (input)=>{
+        if (void 0 !== input.request && !isObject(input.request)) return Promise.resolve(requireObject(input.request, [
+            'options'
+        ]));
+        return Promise.resolve([
+            ...requirePathSegment(input.id, [
+                'id'
+            ]),
+            ...checkTypeList(input.request?.types, [
+                'types'
+            ], {
+                required: false
+            })
+        ]);
     }
-    isServerError() {
-        return this.status >= 500 && this.status < 600;
+});
+const listSubjects = defineEndpoint({
+    auth: 'api-key',
+    decode: (body)=>{
+        const value = asObject(body, 'body');
+        return {
+            ...value,
+            subjects: asArray(value.subjects, 'subjects').map((entry, index)=>{
+                const subject = asObject(entry, `subjects[${index}]`);
+                return {
+                    ...subject,
+                    consents: decodeConsents(subject.consents, `subjects[${index}].consents`),
+                    createdAt: toDate(subject.createdAt, `subjects[${index}].createdAt`)
+                };
+            })
+        };
+    },
+    errorCodes: [
+        'DATABASE_ERROR',
+        'EXTERNAL_ID_REQUIRED',
+        'UNAUTHORIZED'
+    ],
+    idempotent: true,
+    method: 'GET',
+    name: 'subjects.list',
+    path: '/subjects',
+    prepare: (input)=>({
+            params: {},
+            query: {
+                externalId: input.externalId
+            }
+        }),
+    validate: async (input)=>isObject(input) ? [
+            ...requireText(input.externalId, [
+                'externalId'
+            ]),
+            ...await checkSchema(listSubjectsQuerySchema, input)
+        ] : requireObject(input, [])
+});
+const toWireSubject = (input)=>({
+        ...input,
+        givenAt: input.givenAt instanceof Date ? input.givenAt.getTime() : input.givenAt
+    });
+const createSubject = defineEndpoint({
+    auth: 'none',
+    decode: (body)=>{
+        const { ok: _ok, ...value } = asObject(body, 'body');
+        return {
+            ...value,
+            givenAt: toDate(value.givenAt, 'givenAt')
+        };
+    },
+    errorCodes: [
+        'CHOICE_OUT_OF_SCOPE',
+        'CHOICE_PREFERENCE_MISMATCH',
+        'CONFLICT',
+        'DATABASE_ERROR',
+        'INPUT_VALIDATION_FAILED',
+        'POLICY_SNAPSHOT_EXPIRED',
+        'POLICY_SNAPSHOT_INVALID',
+        'POLICY_SNAPSHOT_REQUIRED',
+        'PURPOSE_NOT_ALLOWED',
+        'STALE_POLICY',
+        'SUBJECT_CONFLICT'
+    ],
+    idempotent: true,
+    method: 'POST',
+    name: 'subjects.create',
+    path: '/subjects',
+    prepare: (input)=>({
+            body: toWireSubject(input),
+            params: {}
+        }),
+    validate: (input)=>isObject(input) ? checkSchema(postSubjectInputSchema, toWireSubject(input)) : Promise.resolve(requireObject(input, []))
+});
+const identifySubject = defineEndpoint({
+    auth: 'none',
+    decode: (body)=>{
+        const value = asObject(body, 'body');
+        asObject(value.subject, 'subject');
+        return value;
+    },
+    errorCodes: [
+        'DATABASE_ERROR',
+        'EXTERNAL_ID_REQUIRED',
+        'NOT_FOUND'
+    ],
+    idempotent: true,
+    method: 'PATCH',
+    name: 'subjects.identify',
+    path: '/subjects/:id',
+    prepare: (input)=>({
+            body: input.input,
+            params: {
+                id: input.id
+            }
+        }),
+    validate: async (input)=>[
+            ...requirePathSegment(input.id, [
+                'id'
+            ]),
+            ...isObject(input.input) ? [
+                ...requireText(input.input.externalId, [
+                    'externalId'
+                ]),
+                ...await checkSchema(patchSubjectInputSchema, input.input)
+            ] : requireObject(input.input, [])
+        ]
+});
+const checkConsent = defineEndpoint({
+    auth: 'none',
+    decode: (body, _response, input)=>{
+        const value = asObject(body, 'body');
+        const results = asObject(value.results, 'results');
+        for (const type of new Set([
+            ...Object.keys(results),
+            ...input.types
+        ])){
+            const result = asObject(results[type], `results.${type}`);
+            if ('boolean' != typeof result.hasConsent || 'boolean' != typeof result.isLatestPolicy) throw new DecodeError(`Expected results.${type}.hasConsent and isLatestPolicy to be booleans.`);
+        }
+        return value;
+    },
+    errorCodes: [
+        'DATABASE_ERROR',
+        'EXTERNAL_ID_REQUIRED',
+        'TYPE_REQUIRED'
+    ],
+    idempotent: true,
+    method: 'GET',
+    name: 'consents.check',
+    path: '/consents/check',
+    prepare: (input)=>({
+            params: {},
+            query: {
+                externalId: input.externalId,
+                type: input.types.join(',')
+            }
+        }),
+    validate: (input)=>{
+        if (!isObject(input)) return Promise.resolve(requireObject(input, []));
+        const issues = [
+            ...requireText(input.externalId, [
+                'externalId'
+            ]),
+            ...checkTypeList(input.types, [
+                'types'
+            ], {
+                required: true
+            })
+        ];
+        if (issues.length > 0) return Promise.resolve(issues);
+        return checkSchema(checkConsentQuerySchema, {
+            externalId: input.externalId,
+            type: input.types.join(',')
+        });
     }
-    isNetworkError() {
-        return 0 === this.status || 'NETWORK_ERROR' === this.code;
+});
+const toSummaryQuery = (request)=>({
+        domain: request?.domain,
+        from: request?.from === void 0 ? void 0 : toIsoString(request.from),
+        to: request?.to === void 0 ? void 0 : toIsoString(request.to)
+    });
+const experimentSummary = defineEndpoint({
+    auth: 'api-key',
+    decode: (body)=>{
+        const value = asObject(body, 'body');
+        asArray(value.arms, 'arms');
+        return value;
+    },
+    errorCodes: [
+        'DATABASE_ERROR',
+        'INPUT_VALIDATION_FAILED',
+        'UNAUTHORIZED'
+    ],
+    idempotent: true,
+    method: 'GET',
+    name: 'experiments.summary',
+    path: '/experiments/:id/summary',
+    prepare: (input)=>({
+            params: {
+                id: input.id
+            },
+            query: toSummaryQuery(input.request)
+        }),
+    validate: (input)=>{
+        if (void 0 !== input.request && !isObject(input.request)) return Promise.resolve(requireObject(input.request, [
+            'options'
+        ]));
+        const issues = [
+            ...requirePathSegment(input.id, [
+                'id'
+            ]),
+            ...checkDateLike(input.request?.from, [
+                'from'
+            ], {
+                required: false
+            }),
+            ...checkDateLike(input.request?.to, [
+                'to'
+            ], {
+                required: false
+            })
+        ];
+        if (issues.length > 0) return Promise.resolve(issues);
+        const query = Object.fromEntries(Object.entries(toSummaryQuery(input.request)).filter(([, value])=>void 0 !== value));
+        return checkSchema(experimentSummaryQuerySchema, query);
     }
-    toJSON() {
+});
+const publishLegalDocument = defineEndpoint({
+    auth: 'api-key',
+    decode: (body)=>{
+        const value = asObject(body, 'body');
+        const policy = asObject(value.policy, 'policy');
         return {
-            code: this.code,
-            details: this.details,
-            message: this.message,
-            name: this.name,
-            status: this.status
+            ...value,
+            policy: {
+                ...policy,
+                effectiveDate: toDate(policy.effectiveDate, 'policy.effectiveDate')
+            }
         };
+    },
+    errorCodes: [
+        'CONFLICT',
+        'DATABASE_ERROR',
+        'INPUT_VALIDATION_FAILED',
+        'UNAUTHORIZED'
+    ],
+    idempotent: true,
+    method: 'PUT',
+    name: 'legalDocuments.publish',
+    path: '/legal-documents/:type/current',
+    prepare: (input)=>({
+            body: {
+                effectiveDate: toIsoString(input.input.effectiveDate),
+                hash: input.input.hash,
+                version: input.input.version
+            },
+            params: {
+                type: input.type
+            }
+        }),
+    validate: async (input)=>{
+        if (!isObject(input.input)) return requireObject(input.input, []);
+        const dateIssues = checkDateLike(input.input.effectiveDate, [
+            'effectiveDate'
+        ], {
+            required: true
+        });
+        return [
+            ...await checkSchema(legalDocumentCurrentParamsSchema, {
+                type: input.type
+            }, []),
+            ...requireText(input.input.version, [
+                'version'
+            ]),
+            ...requireText(input.input.hash, [
+                'hash'
+            ]),
+            ...dateIssues,
+            ...dateIssues.length > 0 ? [] : await checkSchema(legalDocumentCurrentInputSchema, {
+                effectiveDate: toIsoString(input.input.effectiveDate),
+                hash: input.input.hash,
+                version: input.input.version
+            })
+        ];
+    }
+});
+const endpoints = {
+    checkConsent: checkConsent,
+    createSubject: createSubject,
+    experimentSummary: experimentSummary,
+    getSubject: getSubject,
+    identifySubject: identifySubject,
+    init: contract_init,
+    listSubjects: listSubjects,
+    manifest: manifest,
+    publishLegalDocument: publishLegalDocument,
+    status: contract_status
+};
+class C15tConfigurationError extends Error {
+    name = 'C15tConfigurationError';
+    issues;
+    constructor(issues){
+        const count = issues.length;
+        super([
+            `Invalid c15t client options: ${count} ${1 === count ? 'problem' : 'problems'}.`,
+            ...issues.map((issue)=>`- ${issue.option}: ${issue.message}`)
+        ].join('\n'));
+        this.issues = issues;
     }
 }
-const error_isC15TError = function(error) {
-    return error instanceof C15TError;
+const DEFAULT_TIMEOUT_MS = 10000;
+const MAX_RETRIES_LIMIT = 10;
+const MAX_TIMER_DELAY_MS = 2147483647;
+const NO_RETRY = {
+    initialDelayMs: 0,
+    maxDelayMs: 0,
+    maxRetries: 0
 };
-const version = '3.0.0-alpha.2';
-const C15T_VERSION_HEADERS = {
-    'x-c15t-version': version
+const DEFAULT_RETRY = {
+    initialDelayMs: 200,
+    maxDelayMs: 5000,
+    maxRetries: 2
 };
-const DEFAULT_RETRY_CONFIG = {
-    backoffFactor: 2,
-    initialDelayMs: 100,
-    maxRetries: 3,
-    nonRetryableStatusCodes: [
-        400,
-        401,
-        403,
-        404
-    ],
-    retryOnNetworkError: true,
-    retryableStatusCodes: [
-        500,
-        502,
-        503,
-        504
-    ]
+const LOOPBACK_HOSTS = new Set([
+    'localhost',
+    '127.0.0.1',
+    '[::1]'
+]);
+const isRecord = (value)=>'object' == typeof value && null !== value && !Array.isArray(value);
+const isNonNegativeInteger = (value)=>'number' == typeof value && Number.isInteger(value) && value >= 0;
+const isTimerDelay = (value)=>isNonNegativeInteger(value) && value <= MAX_TIMER_DELAY_MS;
+const isTimeout = (value)=>isTimerDelay(value) && value > 0;
+const decodeBaseUrl = (value, hasApiKey, issues)=>{
+    if ('string' != typeof value && !(value instanceof URL)) return void issues.push({
+        message: 'Pass the backend URL as a string or URL.',
+        option: 'baseUrl'
+    });
+    let url;
+    try {
+        url = new URL(value);
+    } catch  {
+        issues.push({
+            message: `"${String(value)}" is not an absolute URL. Include the scheme, such as https://example.com/api/c15t.`,
+            option: 'baseUrl'
+        });
+        return;
+    }
+    if ('https:' !== url.protocol && 'http:' !== url.protocol) return void issues.push({
+        message: `Use an http: or https: URL, not ${url.protocol}.`,
+        option: 'baseUrl'
+    });
+    if ('' !== url.search || '' !== url.hash) return void issues.push({
+        message: 'Remove the query string and fragment from the base URL.',
+        option: 'baseUrl'
+    });
+    if (hasApiKey && 'http:' === url.protocol && !LOOPBACK_HOSTS.has(url.hostname)) return void issues.push({
+        message: 'Use https: when sending an API key. Plain http: is accepted only for localhost, 127.0.0.1 and [::1], because anywhere else the key travels in the clear.',
+        option: 'baseUrl'
+    });
+    if (!url.pathname.endsWith('/')) url.pathname = `${url.pathname}/`;
+    return url;
 };
-const fetcher_debugLog = function(debug, method, path, durationMs, status) {
-    if (!debug) return;
-    const timestamp = new Date().toISOString();
-    console.log(`[c15t] ${timestamp} ${method} ${path} (${durationMs}ms) -> ${status}`);
+const decodeHeaders = (value, option, issues)=>{
+    if (void 0 === value) return {};
+    if (!isRecord(value) || !Object.values(value).every((entry)=>'string' == typeof entry)) {
+        issues.push({
+            message: 'Pass headers as an object of string values.',
+            option
+        });
+        return {};
+    }
+    return value;
+};
+const options_decodeRetry = function(value, option, issues, fallback = DEFAULT_RETRY) {
+    if (void 0 === value) return fallback;
+    if (false === value) return NO_RETRY;
+    if (!isRecord(value)) {
+        issues.push({
+            message: 'Pass retry options as an object, or false to disable retries.',
+            option
+        });
+        return fallback;
+    }
+    const base = fallback === NO_RETRY ? DEFAULT_RETRY : fallback;
+    const maxRetries = value.maxRetries ?? base.maxRetries;
+    const initialDelayMs = value.initialDelayMs ?? base.initialDelayMs;
+    const maxDelayMs = value.maxDelayMs ?? base.maxDelayMs;
+    let valid = true;
+    if (!isNonNegativeInteger(maxRetries) || maxRetries > MAX_RETRIES_LIMIT) {
+        issues.push({
+            message: `Use an integer from 0 to ${MAX_RETRIES_LIMIT}.`,
+            option: `${option}.maxRetries`
+        });
+        valid = false;
+    }
+    if (!isTimerDelay(initialDelayMs)) {
+        issues.push({
+            message: `Use an integer from 0 to ${MAX_TIMER_DELAY_MS} milliseconds.`,
+            option: `${option}.initialDelayMs`
+        });
+        valid = false;
+    }
+    if (!isTimerDelay(maxDelayMs)) {
+        issues.push({
+            message: `Use an integer from 0 to ${MAX_TIMER_DELAY_MS} milliseconds.`,
+            option: `${option}.maxDelayMs`
+        });
+        valid = false;
+    }
+    if (!valid) return fallback;
+    return {
+        initialDelayMs: initialDelayMs,
+        maxDelayMs: maxDelayMs,
+        maxRetries: maxRetries
+    };
 };
-const delay = (ms)=>new Promise((resolve)=>{
-        setTimeout(resolve, ms);
+const options_decodeOptions = function(options) {
+    const issues = [];
+    if (!isRecord(options)) throw new C15tConfigurationError([
+        {
+            message: 'Pass an options object with at least baseUrl.',
+            option: 'options'
+        }
+    ]);
+    let apiKey;
+    if (void 0 !== options.apiKey) if ('string' == typeof options.apiKey && '' !== options.apiKey.trim()) ({ apiKey } = options);
+    else issues.push({
+        message: 'Pass the API key as a non-empty string, or leave it out for a client without key-only methods.',
+        option: 'apiKey'
+    });
+    const baseUrl = decodeBaseUrl(options.baseUrl, void 0 !== options.apiKey, issues);
+    const fetchImpl = options.fetch ?? globalThis.fetch;
+    if ('function' != typeof fetchImpl) issues.push({
+        message: 'Pass a fetch function. This runtime has no global fetch, so it must be provided.',
+        option: 'fetch'
     });
-const fetcher_generateUUID = function() {
-    return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/gu, (c)=>{
-        const r = Math.floor(16 * Math.random());
-        const v = 'x' === c ? r : r % 4 + 8;
-        return v.toString(16);
+    const headers = decodeHeaders(options.headers, 'headers', issues);
+    const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    if (!isTimeout(timeoutMs)) issues.push({
+        message: `Use an integer from 1 to ${MAX_TIMER_DELAY_MS} milliseconds.`,
+        option: 'timeoutMs'
     });
+    const retry = options_decodeRetry(options.retry, 'retry', issues);
+    if (void 0 !== options.onEvent && 'function' != typeof options.onEvent) issues.push({
+        message: 'Pass a function.',
+        option: 'onEvent'
+    });
+    if (issues.length > 0 || void 0 === baseUrl) throw new C15tConfigurationError(issues);
+    return {
+        apiKey,
+        baseUrl,
+        fetch: (input, init)=>fetchImpl(input, init),
+        headers,
+        onEvent: options.onEvent,
+        retry,
+        timeoutMs: timeoutMs
+    };
 };
-const fetcher_createResponseContext = function createResponseContext(isSuccess, data = null, error = null, response = null) {
+const options_decodeCallOptions = function(value, client, issues) {
+    const options = isRecord(value) ? value : {};
+    if (void 0 !== value && !isRecord(value)) issues.push({
+        message: 'Pass call options as an object.',
+        option: 'options'
+    });
+    const { signal } = options;
+    if (void 0 !== signal && !(signal instanceof AbortSignal)) issues.push({
+        message: 'Pass an AbortSignal.',
+        option: 'options.signal'
+    });
+    const timeoutMs = options.timeoutMs ?? client.timeoutMs;
+    if (!isTimeout(timeoutMs)) issues.push({
+        message: `Use an integer from 1 to ${MAX_TIMER_DELAY_MS} milliseconds.`,
+        option: 'options.timeoutMs'
+    });
+    const requestId = options.requestId ?? crypto.randomUUID();
+    if ('string' != typeof requestId || '' === requestId) issues.push({
+        message: 'Use a non-empty string.',
+        option: 'options.requestId'
+    });
     return {
-        data,
-        error,
-        expect (message) {
-            if (!isSuccess || null === data) throw new C15TError({
-                cause: error?.cause,
-                code: error?.code,
-                details: error?.details,
-                message,
-                status: error?.status || 0
-            });
-            return data;
-        },
-        map (fn) {
-            if (!isSuccess || null === data) return createResponseContext(false, null, error, response);
-            return createResponseContext(true, fn(data), null, response);
-        },
-        ok: isSuccess,
-        response,
-        unwrap () {
-            if (!isSuccess || null === data) throw new C15TError({
-                cause: error?.cause,
-                code: error?.code,
-                details: error?.details,
-                message: error?.message || 'Request failed',
-                status: error?.status || 0
-            });
-            return data;
+        headers: {
+            ...client.headers,
+            ...decodeHeaders(options.headers, 'options.headers', issues)
         },
-        unwrapOr (defaultValue) {
-            if (!isSuccess || null === data) return defaultValue;
-            return data;
-        }
+        requestId: 'string' == typeof requestId ? requestId : '',
+        retry: options_decodeRetry(options.retry, 'options.retry', issues, client.retry),
+        signal: signal instanceof AbortSignal ? signal : void 0,
+        timeoutMs: isTimeout(timeoutMs) ? timeoutMs : client.timeoutMs
     };
 };
-const fetcher_resolveUrl = function(baseUrl, path) {
-    const cleanBase = baseUrl.endsWith('/') ? baseUrl.slice(0, -1) : baseUrl;
-    const cleanPath = path.startsWith('/') ? path.slice(1) : path;
-    return `${cleanBase}/${cleanPath}`;
+const path_buildPath = function(template, params) {
+    const values = params;
+    return template.replace(/:(?<name>[A-Za-z]+)/gu, (_match, name)=>encodeURIComponent(values[name] ?? ''));
+};
+const version = '3.0.0-alpha.4';
+const RETRYABLE_STATUSES = new Set([
+    408,
+    429,
+    500,
+    502,
+    503,
+    504
+]);
+const ownedHeaders = (options, requestId, hasBody)=>{
+    const headers = {
+        accept: 'application/json',
+        [POLICY_CONTRACT_HEADER]: String(POLICY_CONTRACT_VERSION),
+        'x-c15t-version': version,
+        'x-request-id': requestId
+    };
+    if (hasBody) headers['content-type'] = 'application/json';
+    if (void 0 !== options.apiKey) headers.authorization = `Bearer ${options.apiKey}`;
+    return headers;
 };
-const parseResponseData = async (response)=>{
+const normalizeHeaders = (headers)=>Object.fromEntries(Object.entries(headers).map(([name, value])=>[
+            name.toLowerCase(),
+            value
+        ]));
+const buildUrl = (baseUrl, path, query)=>{
+    const url = new URL(path.replace(/^\//u, ''), baseUrl);
+    for (const [name, value] of Object.entries(query ?? {}))if (void 0 !== value) url.searchParams.set(name, value);
+    return url;
+};
+const emit = (options, event)=>{
     try {
-        const contentType = response.headers.get('content-type');
-        if (contentType?.includes('application/json') && 204 !== response.status && '0' !== response.headers.get('content-length')) return {
-            data: await response.json(),
-            parseError: null
-        };
-        return {
-            data: null,
-            parseError: null
-        };
-    } catch (parseError) {
-        return {
-            data: null,
-            parseError
-        };
+        options.onEvent?.(event);
+    } catch  {}
+};
+const parseRetryAfter = (value)=>{
+    if (null === value) return;
+    const trimmed = value.trim();
+    if (/^\d+$/u.test(trimmed)) return 1000 * Number(trimmed);
+    const date = Date.parse(trimmed);
+    return Number.isNaN(date) ? void 0 : Math.max(0, date - Date.now());
+};
+const backoff = (retry, attempt)=>Math.floor(Math.random() * Math.min(retry.maxDelayMs, retry.initialDelayMs * 2 ** attempt));
+const wait = (ms, signal)=>new Promise((resolve)=>{
+        if (signal?.aborted) return void resolve(false);
+        const cleanup = new AbortController();
+        const timer = setTimeout(()=>{
+            cleanup.abort();
+            resolve(true);
+        }, ms);
+        signal?.addEventListener('abort', ()=>{
+            clearTimeout(timer);
+            resolve(false);
+        }, {
+            once: true,
+            signal: cleanup.signal
+        });
+    });
+const readErrorBody = (text)=>{
+    let body;
+    try {
+        body = JSON.parse(text);
+    } catch  {
+        return {};
     }
+    if ('object' != typeof body || null === body) return {};
+    const { message, cause } = body;
+    const parsed = {};
+    if ('string' == typeof message) parsed.message = message;
+    if ('string' == typeof cause?.code) parsed.code = cause.code;
+    if (isStalePolicyReason(cause?.reason)) parsed.reason = cause.reason;
+    return parsed;
 };
-const processApiError = (response, data, requestMethod, path, durationMs, context, options, retryableStatusCodes, nonRetryableStatusCodes, attemptsMade, maxRetries)=>{
-    const errorData = data;
-    const errorResponse = fetcher_createResponseContext(false, null, {
-        code: errorData?.code || 'API_ERROR',
-        details: errorData?.details || null,
-        message: errorData?.message || `Request failed with status ${response.status}`,
-        status: response.status
-    }, response);
-    const retry = !nonRetryableStatusCodes.includes(response.status) && retryableStatusCodes.includes(response.status) && attemptsMade < maxRetries;
-    if (retry) return {
-        retry: true
-    };
-    fetcher_debugLog(context.debug, requestMethod, path, durationMs, response.status);
-    options?.onError?.(errorResponse, path);
-    if (options?.throw) throw new Error(errorResponse.error?.message || 'Request failed');
-    return {
-        response: errorResponse,
-        retry: false
-    };
+const failure = (error)=>({
+        error,
+        ok: false
+    });
+const invalidInput = (endpoint, cause)=>{
+    const message = cause instanceof Error ? cause.message : String(cause);
+    return failure(new C15tError({
+        cause,
+        code: 'INVALID_INPUT',
+        issues: [
+            {
+                message
+            }
+        ],
+        message: `Invalid input for ${endpoint.name}: ${message}`
+    }));
 };
-const processResponse = async (response, requestMethod, path, durationMs, context, options, retryableStatusCodes, nonRetryableStatusCodes, attemptsMade, maxRetries)=>{
-    const { data, parseError } = await parseResponseData(response);
-    if (parseError) {
-        const errorResponse = fetcher_createResponseContext(false, null, {
-            cause: parseError,
-            code: 'PARSE_ERROR',
-            message: 'Failed to parse response',
+const aborted = (endpoint, requestId, cause)=>failure(new C15tError({
+        cause,
+        code: 'ABORTED',
+        message: `${endpoint.name} was aborted.`,
+        requestId
+    }));
+const describeIssues = (issues)=>issues.slice(0, 5).map((issue)=>issue.path && issue.path.length > 0 ? `${issue.path.map(String).join('.')}: ${issue.message}` : issue.message).join('; ');
+const decodeSuccess = (endpoint, response, text, requestId, input)=>{
+    try {
+        const body = '' === text ? null : JSON.parse(text);
+        const success = {
+            data: endpoint.decode(body, response, input),
+            headers: response.headers,
+            ok: true,
+            requestId,
             status: response.status
-        }, response);
-        options?.onError?.(errorResponse, path);
-        if (options?.throw) throw new Error('Failed to parse response');
-        return {
-            response: errorResponse,
-            retry: false
-        };
-    }
-    if (response.ok) {
-        fetcher_debugLog(context.debug, requestMethod, path, durationMs, response.status);
-        const successResponse = fetcher_createResponseContext(true, data, null, response);
-        options?.onSuccess?.(successResponse);
-        return {
-            response: successResponse,
-            retry: false
         };
+        return success;
+    } catch (error) {
+        return failure(new C15tError({
+            cause: error,
+            code: 'UNEXPECTED_RESPONSE',
+            message: error instanceof DecodeError ? `${endpoint.name} returned a body without the documented shape: ${error.message}` : `${endpoint.name} returned a body that is not JSON.`,
+            requestId,
+            status: response.status
+        }));
     }
-    return processApiError(response, data, requestMethod, path, durationMs, context, options, retryableStatusCodes, nonRetryableStatusCodes, attemptsMade, maxRetries);
 };
-const processFetchError = (fetchError, requestMethod, path, startTime, timeoutMs, context, options, retryOnNetworkError, attemptsMade, maxRetries)=>{
-    if (fetchError instanceof Error && 'Failed to parse response' === fetchError.message) throw fetchError;
-    const isAbortError = fetchError instanceof Error && 'AbortError' === fetchError.name;
-    let message = String(fetchError);
-    if (fetchError instanceof Error) ({ message } = fetchError);
-    if (isAbortError) message = `Request timed out after ${timeoutMs}ms`;
-    const errorResponse = fetcher_createResponseContext(false, null, {
-        cause: fetchError,
-        code: isAbortError ? 'TIMEOUT' : 'NETWORK_ERROR',
-        message,
-        status: 0
-    }, null);
-    const retry = !(fetchError instanceof Response) && retryOnNetworkError && attemptsMade < maxRetries;
-    if (retry) return {
-        retry: true
+const classifyResponse = async (endpoint, response, requestId, input)=>{
+    const text = await response.text();
+    const accepts = endpoint.accepts ?? ((code)=>code >= 200 && code < 300);
+    if (accepts(response.status)) return {
+        kind: 'done',
+        result: decodeSuccess(endpoint, response, text, requestId, input)
+    };
+    const body = readErrorBody(text);
+    const retryable = RETRYABLE_STATUSES.has(response.status);
+    const declared = void 0 !== body.code && endpoint.errorCodes.includes(body.code);
+    const error = declared ? new C15tError({
+        code: body.code,
+        message: body.message ?? `Request failed with status ${response.status}.`,
+        reason: body.reason,
+        requestId,
+        retryable,
+        status: response.status
+    }) : new C15tError({
+        code: 'UNEXPECTED_RESPONSE',
+        message: body.message ?? `${endpoint.name} failed with status ${response.status}${void 0 === body.code ? '' : ` and undocumented code ${body.code}`}.`,
+        requestId,
+        retryable,
+        serverCode: body.code,
+        status: response.status
+    });
+    if (retryable && endpoint.idempotent) return {
+        error,
+        kind: 'retry',
+        retryAfterMs: parseRetryAfter(response.headers.get('retry-after'))
     };
-    fetcher_debugLog(context.debug, requestMethod, path, Date.now() - startTime, 'ERROR');
-    options?.onError?.(errorResponse, path);
-    if (options?.throw) throw fetchError;
     return {
-        response: errorResponse,
-        retry: false
+        kind: 'done',
+        result: failure(error)
     };
 };
-const fetcher_fetcher = function(context, path, options) {
-    const finalRetryConfig = {
-        ...DEFAULT_RETRY_CONFIG,
-        ...context.retryConfig,
-        ...options?.retryConfig || {}
+const attemptOnce = async (plan, attempt)=>{
+    const { call, endpoint, options } = plan;
+    let timeout;
+    const eventBase = {
+        attempt,
+        method: endpoint.method,
+        path: endpoint.path,
+        requestId: call.requestId
     };
-    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;
-    const executeAttempt = async ()=>{
-        const requestId = fetcher_generateUUID();
-        const resolvedUrl = fetcher_resolveUrl(context.baseUrl, path);
-        const url = new URL(resolvedUrl);
-        if (options?.query) Object.entries(options.query).forEach(([key, value])=>{
-            if (null != value) url.searchParams.append(key, String(value));
+    const startedAt = Date.now();
+    emit(options, {
+        ...eventBase,
+        type: 'request'
+    });
+    try {
+        timeout = AbortSignal.timeout(call.timeoutMs);
+        const signal = void 0 === call.signal ? timeout : AbortSignal.any([
+            call.signal,
+            timeout
+        ]);
+        const response = await options.fetch(plan.url, {
+            ...plan.init,
+            signal
         });
-        const timeoutMs = options?.timeout ?? context.timeout;
-        const controller = new AbortController();
-        let timeoutId;
-        if (timeoutMs > 0) timeoutId = setTimeout(()=>controller.abort(), timeoutMs);
-        const requestOptions = {
-            headers: {
-                'Content-Type': 'application/json',
-                ...C15T_VERSION_HEADERS,
-                ...context.headers,
-                'X-Request-ID': requestId,
-                ...options?.headers
-            },
-            method: options?.method || 'GET',
-            signal: controller.signal
+        const outcome = await classifyResponse(endpoint, response, call.requestId, plan.input);
+        emit(options, {
+            ...eventBase,
+            durationMs: Date.now() - startedAt,
+            status: response.status,
+            type: 'response'
+        });
+        return outcome;
+    } catch (error) {
+        if (call.signal?.aborted) return {
+            kind: 'done',
+            result: aborted(endpoint, call.requestId, error)
         };
-        if (options?.body && 'GET' !== requestOptions.method) requestOptions.body = JSON.stringify(options.body);
-        const startTime = Date.now();
-        const requestMethod = requestOptions.method || 'GET';
-        try {
-            const response = await fetch(url.toString(), requestOptions);
-            if (timeoutId) clearTimeout(timeoutId);
-            const outcome = await processResponse(response, requestMethod, path, Date.now() - startTime, context, options, retryableStatusCodes, nonRetryableStatusCodes, attemptsMade, maxRetries);
-            if (!outcome.retry) return outcome.response;
-        } catch (fetchError) {
-            if (timeoutId) clearTimeout(timeoutId);
-            const outcome = processFetchError(fetchError, requestMethod, path, startTime, timeoutMs, context, options, retryOnNetworkError, attemptsMade, maxRetries);
-            if (!outcome.retry) return outcome.response;
-        }
-        attemptsMade += 1;
-        await delay(currentDelay);
-        currentDelay *= backoffFactor;
-        return executeAttempt();
-    };
-    return executeAttempt();
-};
-const CONSENT_CHECK_PATH = '/consents/check';
-const consent_checkConsent = function(context, query, options) {
-    return fetcher_fetcher(context, CONSENT_CHECK_PATH, {
-        method: 'GET',
-        query,
-        ...options
-    });
-};
-const INIT_PATH = '/init';
-const init_init = function(context, options) {
-    return fetcher_fetcher(context, INIT_PATH, {
-        method: 'GET',
-        ...options
-    });
-};
-const STATUS_PATH = '/status';
-const status_status = function(context, options) {
-    return fetcher_fetcher(context, STATUS_PATH, {
-        method: 'GET',
-        ...options
-    });
-};
-const SUBJECTS_PATH = '/subjects';
-const subjects_createSubject = function(context, input, options) {
-    return fetcher_fetcher(context, SUBJECTS_PATH, {
-        body: input,
-        method: 'POST',
-        ...options
-    });
-};
-const subjects_getSubject = function(context, id, query, options) {
-    return fetcher_fetcher(context, `${SUBJECTS_PATH}/${id}`, {
-        method: 'GET',
-        query,
-        ...options
-    });
+        if (void 0 === timeout) return {
+            kind: 'done',
+            result: invalidInput(endpoint, error)
+        };
+        const timedOut = timeout.aborted;
+        const transportError = new C15tError({
+            cause: error,
+            code: timedOut ? 'TIMEOUT' : 'NETWORK_ERROR',
+            message: timedOut ? `${endpoint.name} timed out after ${call.timeoutMs}ms.` : `${endpoint.name} failed before a response arrived: ${error instanceof Error ? error.message : String(error)}`,
+            requestId: call.requestId,
+            retryable: true
+        });
+        return endpoint.idempotent ? {
+            error: transportError,
+            kind: 'retry',
+            retryAfterMs: void 0
+        } : {
+            kind: 'done',
+            result: failure(transportError)
+        };
+    }
 };
-const subjects_patchSubject = function(context, id, input, options) {
-    return fetcher_fetcher(context, `${SUBJECTS_PATH}/${id}`, {
-        body: input,
-        method: 'PATCH',
-        ...options
+const runAttempts = async (plan, attempt)=>{
+    const { call, endpoint, options } = plan;
+    if (call.signal?.aborted) return aborted(endpoint, call.requestId, call.signal.reason);
+    const outcome = await attemptOnce(plan, attempt);
+    if ('done' === outcome.kind) return outcome.result;
+    const delayMs = outcome.retryAfterMs ?? backoff(call.retry, attempt);
+    if (attempt >= call.retry.maxRetries || delayMs > call.retry.maxDelayMs) return failure(outcome.error);
+    emit(options, {
+        attempt,
+        delayMs,
+        error: outcome.error,
+        method: endpoint.method,
+        path: endpoint.path,
+        requestId: call.requestId,
+        type: 'retry'
     });
+    if (!await wait(delayMs, call.signal)) return aborted(endpoint, call.requestId, call.signal?.reason);
+    return runAttempts(plan, attempt + 1);
 };
-const subjects_listSubjects = function(context, query, options) {
-    return fetcher_fetcher(context, SUBJECTS_PATH, {
-        method: 'GET',
-        query,
-        ...options
-    });
+const collectIssues = async (endpoint, input, optionIssues)=>{
+    const fromOptions = optionIssues.map((issue)=>({
+            message: issue.message,
+            path: issue.option.split('.')
+        }));
+    try {
+        return [
+            ...fromOptions,
+            ...await endpoint.validate(input)
+        ];
+    } catch (error) {
+        return [
+            ...fromOptions,
+            {
+                message: error instanceof Error ? error.message : String(error)
+            }
+        ];
+    }
 };
-class C15TClient {
-    context;
-    constructor(options = {}){
-        const baseUrlString = options.baseUrl || ("u" < typeof process ? void 0 : process.env?.C15T_API_URL);
-        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 || ("u" < typeof process ? void 0 : process.env?.C15T_API_TOKEN);
-        const authHeaders = token ? {
-            Authorization: `Bearer ${token}`
-        } : {};
-        const retryConfig = {
-            ...DEFAULT_RETRY_CONFIG,
-            ...options.retryConfig
-        };
-        const debug = options.debug ?? ("u" < typeof process ? false : process.env?.C15T_DEBUG === 'true');
-        const timeout = options.timeout ?? 30000;
-        this.context = {
-            baseUrl: baseUrl.toString(),
-            debug,
+const transport_send = async function(options, endpoint, input, rawCallOptions) {
+    try {
+        const optionIssues = [];
+        const call = options_decodeCallOptions(rawCallOptions, options, optionIssues);
+        const issues = await collectIssues(endpoint, input, optionIssues);
+        if (issues.length > 0) return failure(new C15tError({
+            code: 'INVALID_INPUT',
+            issues,
+            message: `Invalid input for ${endpoint.name}: ${describeIssues(issues)}`
+        }));
+        if ('api-key' === endpoint.auth && void 0 === options.apiKey) return failure(new C15tError({
+            code: 'MISSING_API_KEY',
+            message: `${endpoint.name} needs an API key. Pass apiKey to createC15tClient.`
+        }));
+        const prepared = endpoint.prepare(input);
+        const hasBody = void 0 !== prepared.body;
+        const init = {
             headers: {
-                ...authHeaders,
-                ...options.headers
+                ...normalizeHeaders(call.headers),
+                ...normalizeHeaders(prepared.headers ?? {}),
+                ...ownedHeaders(options, call.requestId, hasBody)
             },
-            retryConfig,
-            timeout
+            method: endpoint.method
         };
+        if (hasBody) init.body = JSON.stringify(prepared.body);
+        return runAttempts({
+            call,
+            endpoint: endpoint,
+            init,
+            input,
+            options,
+            url: buildUrl(options.baseUrl, path_buildPath(endpoint.path, prepared.params), prepared.query)
+        }, 0);
+    } catch (error) {
+        return invalidInput(endpoint, error);
     }
-    status(options) {
-        return status_status(this.context, options);
-    }
-    init(options) {
-        return init_init(this.context, options);
-    }
-    createSubject(input, options) {
-        return subjects_createSubject(this.context, input, options);
-    }
-    getSubject(id, query, options) {
-        return subjects_getSubject(this.context, id, query, options);
-    }
-    patchSubject(id, input, options) {
-        return subjects_patchSubject(this.context, id, input, options);
-    }
-    listSubjects(query, options) {
-        return subjects_listSubjects(this.context, query, options);
-    }
-    checkConsent(query, options) {
-        return consent_checkConsent(this.context, query, options);
-    }
-    $fetch(path, options) {
-        return fetcher_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),
-        list: (query, options)=>this.listSubjects(query, options),
-        patch: (id, input, options)=>this.patchSubject(id, input, options)
-    };
-    meta = {
-        init: (options)=>this.init(options),
-        status: (options)=>this.status(options)
+};
+function createC15tClient(options) {
+    const resolved = options_decodeOptions(options);
+    return {
+        consents: {
+            check: (input, callOptions)=>transport_send(resolved, endpoints.checkConsent, input, callOptions)
+        },
+        experiments: {
+            summary: (id, request, callOptions)=>transport_send(resolved, endpoints.experimentSummary, {
+                    id,
+                    request
+                }, callOptions)
+        },
+        init: (request, callOptions)=>transport_send(resolved, endpoints.init, request, callOptions),
+        legalDocuments: {
+            publish: (type, input, callOptions)=>transport_send(resolved, endpoints.publishLegalDocument, {
+                    input,
+                    type
+                }, callOptions)
+        },
+        manifest: (request, callOptions)=>transport_send(resolved, endpoints.manifest, request, callOptions),
+        status: (callOptions)=>transport_send(resolved, endpoints.status, void 0, callOptions),
+        subjects: {
+            create: (input, callOptions)=>transport_send(resolved, endpoints.createSubject, input, callOptions),
+            get: (id, request, callOptions)=>transport_send(resolved, endpoints.getSubject, {
+                    id,
+                    request
+                }, callOptions),
+            identify: (id, input, callOptions)=>transport_send(resolved, endpoints.identifySubject, {
+                    id,
+                    input
+                }, callOptions),
+            list: (query, callOptions)=>transport_send(resolved, endpoints.listSubjects, query, callOptions)
+        }
     };
 }
-const src_c15tClient = function(options) {
-    return new C15TClient(options);
+const result_unwrap = function(result) {
+    if (result.ok) return result.data;
+    throw result.error;
 };
-export { C15TClient, C15TError, error_isC15TError as isC15TError, fetcher_createResponseContext as createResponseContext, fetcher_fetcher as fetcher, fetcher_resolveUrl as resolveUrl, src_c15tClient as c15tClient };
+export { C15T_API_ERROR_CODES, C15T_CLIENT_ERROR_CODES, C15tError, isC15tError } from "./160.js";
+export { C15tConfigurationError, createC15tClient, result_unwrap as unwrap };