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

package/dist/index.d.ts

@@ -1,47 +1,44 @@
-import { contracts } from '@c15t/backend/contracts';
-import type { ContractRouterClient } from '@orpc/contract';
-import type { JsonifiedClient } from '@orpc/openapi-client';
-/**
- * Configuration options for the C15T SDK client
- */
-export interface C15TClientOptions {
-    /**
-     * Base URL for the API server
-     * @example "https://api.example.com"
-     */
-    baseUrl: string;
-    /**
-     * Authentication token (if needed)
-     * @example "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9..."
-     */
-    token?: string;
-    /**
-     * Additional headers to include with each request
-     */
-    headers?: Record<string, string>;
-    /**
-     * Prefix path for API endpoints
-     * @default "/"
-     */
-    prefix?: string;
-}
+import { C15TClient } from './client';
+import type { C15TClientOptions } from './types';
 /**
  * Creates a type-safe C15T client instance
  *
- * @param options - Configuration options for the client
- * @returns A fully typed client for interacting with the C15T API
+ * @param options - Configuration options for the client. If not provided,
+ *                  falls back to C15T_API_URL and C15T_API_TOKEN environment variables.
+ * @returns A C15TClient instance for interacting with the C15T API
  *
  * @example
  * ```typescript
- * // Create a client with authentication
- * const client = createC15TClient({
+ * // Auto-configure from environment variables
+ * const client = c15tClient();
+ *
+ * // Or provide explicit options
+ * const client = c15tClient({
  *   baseUrl: "https://api.example.com",
  *   token: "your-auth-token"
  * });
  *
- * // Now use the client with full type safety
- * const response = await client.users.getProfile({ userId: "123" });
+ * // Check API status
+ * const status = await client.meta.status();
+ *
+ * // Initialize consent manager
+ * const init = await client.meta.init();
+ *
+ * // Create a subject with consent
+ * const subject = await client.subjects.create({
+ *   type: 'cookie_banner',
+ *   subjectId: 'sub_123',
+ *   domain: 'example.com',
+ *   preferences: { analytics: true },
+ *   givenAt: Date.now(),
+ * });
  * ```
  */
-export declare function c15tClient(options: C15TClientOptions): JsonifiedClient<ContractRouterClient<typeof contracts>>;
+export declare function c15tClient(options?: C15TClientOptions): C15TClient;
+export type { CheckConsentOutput, CheckConsentQuery, ConsentCheckResult, ConsentItem, GetSubjectInput, GetSubjectOutput, GetSubjectParams, GetSubjectQuery, InitOutput, ListSubjectsOutput, ListSubjectsQuery, PatchSubjectFullInput, PatchSubjectOutput, PostSubjectInput, PostSubjectOutput, StatusOutput, SubjectItem, } from '@c15t/schema/types';
+export { C15TClient } from './client';
+export { C15TError, isC15TError } from './error';
+export type { FetcherContext } from './fetcher';
+export { createResponseContext, fetcher, resolveUrl } from './fetcher';
+export type { C15TClientOptions, FetchOptions, ResponseContext, RetryConfig, } from './types';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAEpD,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,gBAAgB,CAAC;AAC3D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAG5D;;GAEG;AACH,MAAM,WAAW,iBAAiB;IACjC;;;OAGG;IACH,OAAO,EAAE,MAAM,CAAC;IAEhB;;;OAGG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;IAEf;;OAEG;IACH,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAEjC;;;OAGG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;CAChB;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,UAAU,CAAC,OAAO,EAAE,iBAAiB,GA0BnB,eAAe,CAC/C,oBAAoB,CAAC,OAAO,SAAS,CAAC,CACtC,CACD"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AACtC,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,SAAS,CAAC;AAEjD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,wBAAgB,UAAU,CAAC,OAAO,CAAC,EAAE,iBAAiB,GAAG,UAAU,CAElE;AAGD,YAAY,EACX,kBAAkB,EAClB,iBAAiB,EACjB,kBAAkB,EAClB,WAAW,EACX,eAAe,EACf,gBAAgB,EAChB,gBAAgB,EAChB,eAAe,EACf,UAAU,EACV,kBAAkB,EAClB,iBAAiB,EACjB,qBAAqB,EACrB,kBAAkB,EAClB,gBAAgB,EAChB,iBAAiB,EACjB,YAAY,EACZ,WAAW,GACX,MAAM,oBAAoB,CAAC;AAE5B,OAAO,EAAE,UAAU,EAAE,MAAM,UAAU,CAAC;AAEtC,OAAO,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AACjD,YAAY,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AAEhD,OAAO,EAAE,qBAAqB,EAAE,OAAO,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAEvE,YAAY,EACX,iBAAiB,EACjB,YAAY,EACZ,eAAe,EACf,WAAW,GACX,MAAM,SAAS,CAAC"}

package/dist/index.js

@@ -1,19 +1,368 @@
-import { contracts } from "@c15t/backend/contracts";
-import { createORPCClient } from "@orpc/client";
-import { OpenAPILink } from "@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 OpenAPILink(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 createORPCClient(link);
 }
-export { c15tClient };
+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);
+}
+export { C15TClient, C15TError, c15tClient, createResponseContext, fetcher, isC15TError, resolveUrl };

package/dist/testing.d.ts

@@ -0,0 +1,132 @@
+/**
+ * Testing utilities for @c15t/node-sdk
+ *
+ * These utilities help users mock the C15T client in their tests.
+ *
+ * @example
+ * ```typescript
+ * import { createMockClient, createMockResponse } from '@c15t/node-sdk/testing';
+ *
+ * const mockClient = createMockClient({
+ *   getSubject: async () => createMockResponse({ id: 'sub_123', consents: [] }),
+ * });
+ *
+ * // Use mockClient in your tests
+ * const result = await mockClient.getSubject('sub_123');
+ * expect(result.data?.id).toBe('sub_123');
+ * ```
+ */
+import type { ResponseContext } from './types';
+/**
+ * Creates a mock ResponseContext for testing
+ *
+ * @param data - The data to return in the response
+ * @param options - Optional configuration for the mock response
+ * @returns A ResponseContext object
+ *
+ * @example
+ * ```typescript
+ * const response = createMockResponse({ id: 'sub_123' });
+ * expect(response.ok).toBe(true);
+ * expect(response.data?.id).toBe('sub_123');
+ * ```
+ */
+export declare function createMockResponse<T>(data: T, options?: {
+    ok?: boolean;
+    error?: {
+        message: string;
+        status: number;
+        code?: string;
+        details?: Record<string, unknown> | null;
+    };
+    response?: Response;
+}): ResponseContext<T>;
+/**
+ * Creates a mock error ResponseContext for testing
+ *
+ * @param error - The error details
+ * @returns A ResponseContext object representing an error
+ *
+ * @example
+ * ```typescript
+ * const response = createMockErrorResponse({
+ *   message: 'Not found',
+ *   status: 404,
+ *   code: 'NOT_FOUND',
+ * });
+ * expect(response.ok).toBe(false);
+ * expect(response.error?.status).toBe(404);
+ * ```
+ */
+export declare function createMockErrorResponse<T = unknown>(error: {
+    message: string;
+    status: number;
+    code?: string;
+    details?: Record<string, unknown> | null;
+}): ResponseContext<T>;
+/**
+ * Type for mock method implementations
+ */
+export type MockMethodImplementation<TInput, TOutput> = (input: TInput) => ResponseContext<TOutput> | Promise<ResponseContext<TOutput>>;
+/**
+ * Type for mock client overrides
+ */
+export interface MockClientOverrides {
+    status?: MockMethodImplementation<void, unknown>;
+    init?: MockMethodImplementation<void, unknown>;
+    checkConsent?: MockMethodImplementation<unknown, unknown>;
+    createSubject?: MockMethodImplementation<unknown, unknown>;
+    getSubject?: MockMethodImplementation<string, unknown>;
+    patchSubject?: MockMethodImplementation<unknown, unknown>;
+    listSubjects?: MockMethodImplementation<unknown, unknown>;
+}
+/**
+ * Creates a mock C15T client for testing
+ *
+ * @param overrides - Method implementations to override
+ * @returns A mock client object
+ *
+ * @example
+ * ```typescript
+ * const mockClient = createMockClient({
+ *   getSubject: async (id) => createMockResponse({
+ *     id,
+ *     externalId: 'user_123',
+ *     consents: [],
+ *   }),
+ *   checkConsent: async () => createMockResponse({
+ *     results: { analytics: { hasConsent: true } },
+ *   }),
+ * });
+ *
+ * // Use in tests
+ * const result = await mockClient.getSubject('sub_123');
+ * ```
+ */
+export declare function createMockClient(overrides?: MockClientOverrides): {
+    status: () => Promise<ResponseContext<unknown>>;
+    init: () => Promise<ResponseContext<unknown>>;
+    checkConsent: (query: unknown) => Promise<ResponseContext<unknown>>;
+    createSubject: (input: unknown) => Promise<ResponseContext<unknown>>;
+    getSubject: (id: string) => Promise<ResponseContext<unknown>>;
+    patchSubject: (id: string, input: unknown) => Promise<ResponseContext<unknown>>;
+    listSubjects: (query?: unknown) => Promise<ResponseContext<unknown>>;
+    consent: {
+        check: (query: unknown) => Promise<ResponseContext<unknown>>;
+    };
+    subjects: {
+        create: (input: unknown) => Promise<ResponseContext<unknown>>;
+        get: (id: string) => Promise<ResponseContext<unknown>>;
+        patch: (id: string, input: unknown) => Promise<ResponseContext<unknown>>;
+        list: (query?: unknown) => Promise<ResponseContext<unknown>>;
+    };
+    meta: {
+        status: () => Promise<ResponseContext<unknown>>;
+        init: () => Promise<ResponseContext<unknown>>;
+    };
+};
+/**
+ * Type representing the mock client returned by createMockClient
+ */
+export type MockC15TClient = ReturnType<typeof createMockClient>;
+//# sourceMappingURL=testing.d.ts.map

package/dist/testing.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"testing.d.ts","sourceRoot":"","sources":["../src/testing.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAE/C;;;;;;;;;;;;;GAaG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,EACnC,IAAI,EAAE,CAAC,EACP,OAAO,GAAE;IACR,EAAE,CAAC,EAAE,OAAO,CAAC;IACb,KAAK,CAAC,EAAE;QACP,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,CAAC;IACF,QAAQ,CAAC,EAAE,QAAQ,CAAC;CACf,GACJ,eAAe,CAAC,CAAC,CAAC,CA0CpB;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,uBAAuB,CAAC,CAAC,GAAG,OAAO,EAAE,KAAK,EAAE;IAC3D,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,IAAI,CAAC;CACzC,GAAG,eAAe,CAAC,CAAC,CAAC,CAErB;AAED;;GAEG;AACH,MAAM,MAAM,wBAAwB,CAAC,MAAM,EAAE,OAAO,IAAI,CACvD,KAAK,EAAE,MAAM,KACT,eAAe,CAAC,OAAO,CAAC,GAAG,OAAO,CAAC,eAAe,CAAC,OAAO,CAAC,CAAC,CAAC;AAElE;;GAEG;AACH,MAAM,WAAW,mBAAmB;IACnC,MAAM,CAAC,EAAE,wBAAwB,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;IACjD,IAAI,CAAC,EAAE,wBAAwB,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;IAC/C,YAAY,CAAC,EAAE,wBAAwB,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;IAC1D,aAAa,CAAC,EAAE,wBAAwB,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;IAC3D,UAAU,CAAC,EAAE,wBAAwB,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IACvD,YAAY,CAAC,EAAE,wBAAwB,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;IAC1D,YAAY,CAAC,EAAE,wBAAwB,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC;CAC1D;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,gBAAgB,CAAC,SAAS,GAAE,mBAAwB;;;0BAoB5C,OAAO;2BACN,OAAO;qBACb,MAAM;uBACJ,MAAM,SAAS,OAAO;2BAOlB,OAAO;;uBAId,OAAO;;;wBAGN,OAAO;kBACb,MAAM;oBACJ,MAAM,SAAS,OAAO;uBAOnB,OAAO;;;;;;EAOxB;AAED;;GAEG;AACH,MAAM,MAAM,cAAc,GAAG,UAAU,CAAC,OAAO,gBAAgB,CAAC,CAAC"}