@hazeljs/data 0.2.0-alpha.1

package/dist/schema/schema.test.js

@@ -0,0 +1,411 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const schema_1 = require("./schema");
+describe('Schema', () => {
+    describe('string', () => {
+        it('validates string', () => {
+            const result = schema_1.Schema.string().validate('hello');
+            expect(result.success).toBe(true);
+            if (result.success)
+                expect(result.data).toBe('hello');
+        });
+        it('rejects non-string', () => {
+            const result = schema_1.Schema.string().validate(123);
+            expect(result.success).toBe(false);
+            if (!result.success)
+                expect(result.errors[0].message).toBe('Expected string');
+        });
+        it('email validation', () => {
+            expect(schema_1.Schema.string().email().validate('a@b.com').success).toBe(true);
+            expect(schema_1.Schema.string().email().validate('invalid').success).toBe(false);
+        });
+        it('min length', () => {
+            expect(schema_1.Schema.string().min(3).validate('abc').success).toBe(true);
+            expect(schema_1.Schema.string().min(3).validate('ab').success).toBe(false);
+        });
+        it('max length', () => {
+            expect(schema_1.Schema.string().max(3).validate('abc').success).toBe(true);
+            expect(schema_1.Schema.string().max(2).validate('abc').success).toBe(false);
+        });
+        it('uuid validation', () => {
+            const valid = '550e8400-e29b-41d4-a716-446655440000';
+            expect(schema_1.Schema.string().uuid().validate(valid).success).toBe(true);
+            expect(schema_1.Schema.string().uuid().validate('not-uuid').success).toBe(false);
+        });
+        it('oneOf validation', () => {
+            expect(schema_1.Schema.string().oneOf(['a', 'b']).validate('a').success).toBe(true);
+            expect(schema_1.Schema.string().oneOf(['a', 'b']).validate('c').success).toBe(false);
+        });
+    });
+    describe('number', () => {
+        it('validates number', () => {
+            const result = schema_1.Schema.number().validate(42);
+            expect(result.success).toBe(true);
+            if (result.success)
+                expect(result.data).toBe(42);
+        });
+        it('rejects non-number', () => {
+            expect(schema_1.Schema.number().validate('42').success).toBe(false);
+            expect(schema_1.Schema.number().validate(NaN).success).toBe(false);
+        });
+        it('min/max', () => {
+            expect(schema_1.Schema.number().min(0).max(100).validate(50).success).toBe(true);
+            expect(schema_1.Schema.number().min(0).validate(-1).success).toBe(false);
+            expect(schema_1.Schema.number().max(10).validate(11).success).toBe(false);
+        });
+    });
+    describe('date', () => {
+        it('validates Date', () => {
+            const d = new Date();
+            const result = schema_1.Schema.date().validate(d);
+            expect(result.success).toBe(true);
+            if (result.success)
+                expect(result.data).toBe(d);
+        });
+        it('validates date string', () => {
+            const result = schema_1.Schema.date().validate('2024-01-01');
+            expect(result.success).toBe(true);
+        });
+        it('rejects invalid date', () => {
+            expect(schema_1.Schema.date().validate('invalid').success).toBe(false);
+            expect(schema_1.Schema.date().validate({}).success).toBe(false);
+        });
+    });
+    describe('object', () => {
+        it('validates object shape', () => {
+            const schema = schema_1.Schema.object({
+                name: schema_1.Schema.string(),
+                age: schema_1.Schema.number(),
+            });
+            const result = schema.validate({ name: 'John', age: 30 });
+            expect(result.success).toBe(true);
+            if (result.success) {
+                expect(result.data.name).toBe('John');
+                expect(result.data.age).toBe(30);
+            }
+        });
+        it('rejects invalid fields', () => {
+            const schema = schema_1.Schema.object({
+                age: schema_1.Schema.number(),
+            });
+            const result = schema.validate({ age: 'thirty' });
+            expect(result.success).toBe(false);
+            if (!result.success)
+                expect(result.errors.length).toBeGreaterThan(0);
+        });
+        it('rejects non-object', () => {
+            expect(schema_1.Schema.object({}).validate('str').success).toBe(false);
+            expect(schema_1.Schema.object({}).validate(null).success).toBe(false);
+            expect(schema_1.Schema.object({}).validate([]).success).toBe(false);
+        });
+    });
+    describe('array', () => {
+        it('validates array of items', () => {
+            const schema = schema_1.Schema.array(schema_1.Schema.number());
+            const result = schema.validate([1, 2, 3]);
+            expect(result.success).toBe(true);
+            if (result.success)
+                expect(result.data).toEqual([1, 2, 3]);
+        });
+        it('rejects invalid items', () => {
+            const schema = schema_1.Schema.array(schema_1.Schema.number());
+            const result = schema.validate([1, 'two', 3]);
+            expect(result.success).toBe(false);
+        });
+        it('rejects non-array', () => {
+            expect(schema_1.Schema.array(schema_1.Schema.string()).validate({}).success).toBe(false);
+        });
+    });
+    describe('boolean', () => {
+        it('validates boolean', () => {
+            expect(schema_1.Schema.boolean().validate(true).success).toBe(true);
+            expect(schema_1.Schema.boolean().validate(false).success).toBe(true);
+            expect(schema_1.Schema.boolean().validate(1).success).toBe(false);
+        });
+    });
+    describe('literal', () => {
+        it('validates literal value', () => {
+            expect(schema_1.Schema.literal('active').validate('active').success).toBe(true);
+            expect(schema_1.Schema.literal('active').validate('inactive').success).toBe(false);
+            expect(schema_1.Schema.literal(42).validate(42).success).toBe(true);
+        });
+    });
+    describe('union', () => {
+        it('validates union of schemas', () => {
+            const schema = schema_1.Schema.union([schema_1.Schema.literal('a'), schema_1.Schema.literal('b')]);
+            expect(schema.validate('a').success).toBe(true);
+            expect(schema.validate('b').success).toBe(true);
+            expect(schema.validate('c').success).toBe(false);
+        });
+    });
+    describe('optional and default', () => {
+        it('optional accepts undefined', () => {
+            const schema = schema_1.Schema.string().optional();
+            expect(schema.validate(undefined).success).toBe(true);
+            expect(schema.validate('x').success).toBe(true);
+        });
+        it('default returns default for undefined', () => {
+            const schema = schema_1.Schema.string().default('fallback');
+            const result = schema.validate(undefined);
+            expect(result.success).toBe(true);
+            if (result.success)
+                expect(result.data).toBe('fallback');
+        });
+    });
+    describe('transform and refine', () => {
+        it('transform coerces after validation', () => {
+            const schema = schema_1.Schema.number().transform((n) => n * 2);
+            const result = schema.validate(21);
+            expect(result.success).toBe(true);
+            if (result.success)
+                expect(result.data).toBe(42);
+        });
+        it('refine adds custom constraint', () => {
+            const schema = schema_1.Schema.number().refine((n) => n % 2 === 0, 'Must be even');
+            expect(schema.validate(4).success).toBe(true);
+            expect(schema.validate(3).success).toBe(false);
+        });
+    });
+    describe('toJsonSchema', () => {
+        it('exports string schema', () => {
+            const js = schema_1.Schema.string().toJsonSchema();
+            expect(js).toMatchObject({ type: 'string' });
+        });
+        it('exports object schema', () => {
+            const schema = schema_1.Schema.object({ name: schema_1.Schema.string() });
+            const js = schema.toJsonSchema();
+            expect(js).toMatchObject({ type: 'object' });
+            expect(js).toHaveProperty('properties');
+        });
+        it('exports array schema', () => {
+            const schema = schema_1.Schema.array(schema_1.Schema.number());
+            const js = schema.toJsonSchema();
+            expect(js).toMatchObject({ type: 'array' });
+            expect(js).toHaveProperty('items');
+        });
+        it('exports literal schema', () => {
+            const js = schema_1.Schema.literal('x').toJsonSchema();
+            expect(js).toMatchObject({ const: 'x' });
+        });
+    });
+    describe('nullable', () => {
+        it('accepts null', () => {
+            const schema = schema_1.Schema.string().nullable();
+            expect(schema.validate(null).success).toBe(true);
+            expect(schema.validate('x').success).toBe(true);
+        });
+    });
+    describe('validateAsync', () => {
+        it('validates with async refinements', async () => {
+            const schema = schema_1.Schema.number().refineAsync(async (n) => n > 0, 'Must be positive');
+            const result = await schema.validateAsync(5);
+            expect(result.success).toBe(true);
+            const fail = await schema.validateAsync(-1);
+            expect(fail.success).toBe(false);
+        });
+    });
+    describe('number integer and url', () => {
+        it('integer rejects decimals', () => {
+            expect(schema_1.Schema.number().integer().validate(5).success).toBe(true);
+            expect(schema_1.Schema.number().integer().validate(5.5).success).toBe(false);
+        });
+        it('string url validates', () => {
+            expect(schema_1.Schema.string().url().validate('https://example.com').success).toBe(true);
+            expect(schema_1.Schema.string().url().validate('not-a-url').success).toBe(false);
+        });
+    });
+    describe('object pick omit extend strict', () => {
+        const base = schema_1.Schema.object({ a: schema_1.Schema.number(), b: schema_1.Schema.string(), c: schema_1.Schema.boolean() });
+        it('pick selects keys', () => {
+            const picked = base.pick(['a', 'c']);
+            const result = picked.validate({ a: 1, b: 'x', c: true });
+            expect(result.success).toBe(true);
+            if (result.success) {
+                expect(result.data).toEqual({ a: 1, c: true });
+            }
+        });
+        it('omit removes keys', () => {
+            const omitted = base.omit(['b']);
+            const result = omitted.validate({ a: 1, b: 'x', c: true });
+            expect(result.success).toBe(true);
+            if (result.success) {
+                expect(result.data).toEqual({ a: 1, c: true });
+            }
+        });
+        it('extend adds fields', () => {
+            const extended = base.extend({ d: schema_1.Schema.number() });
+            const result = extended.validate({ a: 1, b: 'x', c: true, d: 4 });
+            expect(result.success).toBe(true);
+            if (result.success)
+                expect(result.data.d).toBe(4);
+        });
+        it('strict rejects unknown keys', () => {
+            const strict = base.strict();
+            const result = strict.validate({ a: 1, b: 'x', c: true, extra: 'bad' });
+            expect(result.success).toBe(false);
+        });
+    });
+    describe('array min max nonempty', () => {
+        it('min rejects short arrays', () => {
+            const schema = schema_1.Schema.array(schema_1.Schema.number()).min(2);
+            expect(schema.validate([1, 2]).success).toBe(true);
+            expect(schema.validate([1]).success).toBe(false);
+        });
+        it('nonempty rejects empty', () => {
+            const schema = schema_1.Schema.array(schema_1.Schema.string()).nonempty();
+            expect(schema.validate(['x']).success).toBe(true);
+            expect(schema.validate([]).success).toBe(false);
+        });
+    });
+    describe('transform throws', () => {
+        it('transform error is caught', () => {
+            const schema = schema_1.Schema.number().transform((n) => {
+                if (n < 0)
+                    throw new Error('Negative');
+                return n;
+            });
+            const result = schema.validate(-1);
+            expect(result.success).toBe(false);
+            if (!result.success)
+                expect(result.errors[0].message).toBe('Negative');
+        });
+        it('transform non-Error throw uses generic message', () => {
+            const schema = schema_1.Schema.number().transform(() => {
+                throw 'string error';
+            });
+            const result = schema.validate(1);
+            expect(result.success).toBe(false);
+            if (!result.success)
+                expect(result.errors[0].message).toBe('Transform failed');
+        });
+    });
+    describe('string pattern required trim', () => {
+        it('pattern validates regex', () => {
+            expect(schema_1.Schema.string().pattern(/^\d+$/).validate('123').success).toBe(true);
+            expect(schema_1.Schema.string().pattern(/^\d+$/, 'Digits only').validate('abc').success).toBe(false);
+        });
+        it('required rejects empty string', () => {
+            expect(schema_1.Schema.string().required().validate('x').success).toBe(true);
+            expect(schema_1.Schema.string().required().validate('').success).toBe(false);
+        });
+        it('trim preprocesses', () => {
+            const result = schema_1.Schema.string().trim().validate('  hi  ');
+            expect(result.success).toBe(true);
+            if (result.success)
+                expect(result.data).toBe('hi');
+        });
+    });
+    describe('number positive negative multipleOf', () => {
+        it('positive rejects zero and negative', () => {
+            expect(schema_1.Schema.number().positive().validate(1).success).toBe(true);
+            expect(schema_1.Schema.number().positive().validate(0).success).toBe(false);
+            expect(schema_1.Schema.number().positive().validate(-1).success).toBe(false);
+        });
+        it('negative rejects zero and positive', () => {
+            expect(schema_1.Schema.number().negative().validate(-1).success).toBe(true);
+            expect(schema_1.Schema.number().negative().validate(0).success).toBe(false);
+        });
+        it('multipleOf validates', () => {
+            expect(schema_1.Schema.number().multipleOf(5).validate(10).success).toBe(true);
+            expect(schema_1.Schema.number().multipleOf(5).validate(7).success).toBe(false);
+        });
+    });
+    describe('number and boolean default', () => {
+        it('number default for undefined', () => {
+            const schema = schema_1.Schema.number().default(42);
+            const result = schema.validate(undefined);
+            expect(result.success).toBe(true);
+            if (result.success)
+                expect(result.data).toBe(42);
+        });
+        it('boolean default for undefined', () => {
+            const schema = schema_1.Schema.boolean().default(true);
+            const result = schema.validate(undefined);
+            expect(result.success).toBe(true);
+            if (result.success)
+                expect(result.data).toBe(true);
+        });
+    });
+    describe('date min max default', () => {
+        it('date min max', () => {
+            const min = new Date('2024-01-01');
+            const max = new Date('2024-12-31');
+            const schema = schema_1.Schema.date().min(min).max(max);
+            expect(schema.validate(new Date('2024-06-15')).success).toBe(true);
+            expect(schema.validate(new Date('2023-06-15')).success).toBe(false);
+            expect(schema.validate(new Date('2025-06-15')).success).toBe(false);
+        });
+        it('date default for undefined', () => {
+            const d = new Date('2024-01-01');
+            const schema = schema_1.Schema.date().default(d);
+            const result = schema.validate(undefined);
+            expect(result.success).toBe(true);
+            if (result.success)
+                expect(result.data).toEqual(d);
+        });
+    });
+    describe('nullable toJsonSchema', () => {
+        it('nullable string has type array', () => {
+            const js = schema_1.Schema.string().nullable().toJsonSchema();
+            expect(js.type).toEqual(['string', 'null']);
+        });
+        it('nullable without base type', () => {
+            const schema = schema_1.Schema.literal('x').nullable();
+            const js = schema.toJsonSchema();
+            expect(js.type).toEqual(['null']);
+        });
+    });
+    describe('optional toJsonSchema', () => {
+        it('optional has _optional flag', () => {
+            const js = schema_1.Schema.string().optional().toJsonSchema();
+            expect(js._optional).toBe(true);
+        });
+    });
+    describe('object pick filters keys not in shape', () => {
+        it('pick ignores keys not in shape', () => {
+            const base = schema_1.Schema.object({ a: schema_1.Schema.number() });
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            const picked = base.pick(['a', 'nonexistent']);
+            const result = picked.validate({ a: 1 });
+            expect(result.success).toBe(true);
+            if (result.success)
+                expect(result.data).toEqual({ a: 1 });
+        });
+    });
+    describe('array max', () => {
+        it('max rejects long arrays', () => {
+            const schema = schema_1.Schema.array(schema_1.Schema.number()).max(2);
+            expect(schema.validate([1, 2]).success).toBe(true);
+            expect(schema.validate([1, 2, 3]).success).toBe(false);
+        });
+    });
+    describe('refineAsync', () => {
+        it('refineAsync failure path', async () => {
+            const schema = schema_1.Schema.number().refineAsync(async (n) => n > 10, 'Must be > 10');
+            const result = await schema.validateAsync(5);
+            expect(result.success).toBe(false);
+            if (!result.success)
+                expect(result.errors[0].message).toBe('Must be > 10');
+        });
+    });
+    describe('buildSchema refine failure', () => {
+        it('sync refine failure returns error', () => {
+            const schema = schema_1.Schema.number().refine((n) => n > 0, 'Must be positive');
+            const result = schema.validate(-1);
+            expect(result.success).toBe(false);
+            if (!result.success)
+                expect(result.errors[0].message).toBe('Must be positive');
+        });
+    });
+    describe('validateAsync with sync failure', () => {
+        it('returns sync failure without running async refinements', async () => {
+            const schema = schema_1.Schema.number()
+                .refine((n) => n > 0, 'sync fail')
+                .refineAsync(async () => true, 'async');
+            const result = await schema.validateAsync(-1);
+            expect(result.success).toBe(false);
+            if (!result.success)
+                expect(result.errors[0].message).toBe('sync fail');
+        });
+    });
+});

package/dist/streaming/flink/flink.client.d.ts

@@ -0,0 +1,96 @@
+import type { FlinkAuthConfig, FlinkJobConfig } from '../../data.types';
+export interface FlinkClientConfig {
+    url: string;
+    auth?: FlinkAuthConfig;
+    timeout?: number;
+    retries?: number;
+}
+export interface FlinkJobInfo {
+    id: string;
+    status: string;
+    startTime?: number;
+    endTime?: number;
+    duration?: number;
+}
+export interface FlinkJobSubmitRequest {
+    jobName?: string;
+    parallelism?: number;
+    savepointPath?: string;
+    allowNonRestoredState?: boolean;
+    programArgs?: string;
+    entryClass?: string;
+    jarFile?: string;
+}
+/**
+ * Flink Client - REST API client for Apache Flink clusters
+ * Interacts with Flink JobManager REST API
+ */
+export declare class FlinkClient {
+    readonly url: string;
+    private readonly config;
+    constructor(config: FlinkClientConfig);
+    private request;
+    listJobs(): Promise<FlinkJobInfo[]>;
+    getJobStatus(jobId: string): Promise<{
+        state: string;
+        startTime?: number;
+        duration?: number;
+    }>;
+    cancelJob(jobId: string): Promise<void>;
+    stopJob(jobId: string, savepointPath?: string): Promise<{
+        'request-id': string;
+    }>;
+    createSavepoint(jobId: string, savepointPath?: string): Promise<{
+        'request-id': string;
+    }>;
+    getClusterInfo(): Promise<{
+        taskmanagers?: number;
+        'slots-total'?: number;
+    }>;
+    getTaskManagers(): Promise<unknown[]>;
+    /**
+     * Upload a JAR file to the Flink cluster.
+     * @param jarPath Local filesystem path to the JAR file
+     * @returns The Flink JAR ID for subsequent run calls
+     */
+    uploadJar(jarPath: string): Promise<string>;
+    /**
+     * Run a previously uploaded JAR as a Flink job.
+     * @param jarId   The JAR ID returned by uploadJar()
+     * @param request Optional run parameters (entry class, parallelism, args, etc.)
+     * @returns The Flink job ID
+     */
+    runJar(jarId: string, request?: FlinkJobSubmitRequest): Promise<string>;
+    /**
+     * Submit a SQL statement to the Flink SQL Gateway.
+     * Requires Flink SQL Gateway to be running.
+     * @param sql       The SQL statement to execute (CREATE TABLE, INSERT INTO, etc.)
+     * @param sessionId An existing Flink SQL Gateway session ID
+     */
+    submitSql(sql: string, sessionId: string): Promise<string>;
+    /**
+     * Create a new SQL Gateway session.
+     * @returns The session ID
+     */
+    createSqlSession(properties?: Record<string, string>): Promise<string>;
+    /**
+     * Submit a job to Flink cluster.
+     * Requires `jarFile` path in the jobConfig or uses FlinkJobSubmitRequest.jarFile.
+     *
+     * Workflow: upload JAR → run JAR → return job ID.
+     */
+    submitJob(jobConfig: FlinkJobConfig, request?: FlinkJobSubmitRequest): Promise<string>;
+    /**
+     * List uploaded JARs on the cluster.
+     */
+    listJars(): Promise<Array<{
+        id: string;
+        name: string;
+        uploaded: number;
+    }>>;
+    /**
+     * Delete an uploaded JAR from the cluster.
+     */
+    deleteJar(jarId: string): Promise<void>;
+}
+//# sourceMappingURL=flink.client.d.ts.map

package/dist/streaming/flink/flink.client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"flink.client.d.ts","sourceRoot":"","sources":["../../../src/streaming/flink/flink.client.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AAExE,MAAM,WAAW,iBAAiB;IAChC,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,CAAC,EAAE,eAAe,CAAC;IACvB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,YAAY;IAC3B,EAAE,EAAE,MAAM,CAAC;IACX,MAAM,EAAE,MAAM,CAAC;IACf,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,qBAAqB;IACpC,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,qBAAqB,CAAC,EAAE,OAAO,CAAC;IAChC,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED;;;GAGG;AACH,qBAAa,WAAW;IACtB,SAAgB,GAAG,EAAE,MAAM,CAAC;IAC5B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAoB;gBAE/B,MAAM,EAAE,iBAAiB;YASvB,OAAO;IA4Cf,QAAQ,IAAI,OAAO,CAAC,YAAY,EAAE,CAAC;IA+BnC,YAAY,CAChB,KAAK,EAAE,MAAM,GACZ,OAAO,CAAC;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,SAAS,CAAC,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IAY9D,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAIvC,OAAO,CAAC,KAAK,EAAE,MAAM,EAAE,aAAa,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;QAAE,YAAY,EAAE,MAAM,CAAA;KAAE,CAAC;IAKjF,eAAe,CAAC,KAAK,EAAE,MAAM,EAAE,aAAa,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;QAAE,YAAY,EAAE,MAAM,CAAA;KAAE,CAAC;IAKzF,cAAc,IAAI,OAAO,CAAC;QAAE,YAAY,CAAC,EAAE,MAAM,CAAC;QAAC,aAAa,CAAC,EAAE,MAAM,CAAA;KAAE,CAAC;IAI5E,eAAe,IAAI,OAAO,CAAC,OAAO,EAAE,CAAC;IAK3C;;;;OAIG;IACG,SAAS,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IA8DjD;;;;;OAKG;IACG,MAAM,CAAC,KAAK,EAAE,MAAM,EAAE,OAAO,GAAE,qBAA0B,GAAG,OAAO,CAAC,MAAM,CAAC;IAejF;;;;;OAKG;IACG,SAAS,CAAC,GAAG,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC;IAWhE;;;OAGG;IACG,gBAAgB,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,OAAO,CAAC,MAAM,CAAC;IAW5E;;;;;OAKG;IACG,SAAS,CAAC,SAAS,EAAE,cAAc,EAAE,OAAO,GAAE,qBAA0B,GAAG,OAAO,CAAC,MAAM,CAAC;IAoBhG;;OAEG;IACG,QAAQ,IAAI,OAAO,CAAC,KAAK,CAAC;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC;IAOhF;;OAEG;IACG,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;CAG9C"}