@eide/uniformgen 0.1.0

package/dist/commands/init.js

@@ -0,0 +1,113 @@
+import { promises as fs } from 'fs';
+import { join, resolve } from 'path';
+import chalk from 'chalk';
+import { getCredentials } from '../auth/credentials.js';
+import { generateSchemaFile } from '../schema/schema-loader.js';
+/**
+ * Fetch entity models from the API
+ */
+async function fetchRemoteSchemas(apiUrl, accessToken) {
+    const response = await fetch(`${apiUrl}/graphql`, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            Authorization: `Bearer ${accessToken}`,
+        },
+        body: JSON.stringify({
+            query: `
+        query GetEntityModels {
+          entityModels {
+            key
+            name
+            pluralName
+            description
+            tier
+            editorMode
+            fields {
+              key
+              type
+              label
+              required
+              helpText
+              placeholder
+              defaultValue
+              options
+              validation {
+                type
+                value
+                message
+              }
+            }
+            modes {
+              records
+              inline
+            }
+          }
+        }
+      `,
+        }),
+    });
+    if (!response.ok) {
+        throw new Error(`Failed to fetch schemas: ${response.statusText}`);
+    }
+    const result = (await response.json());
+    if (result.errors && result.errors.length > 0) {
+        throw new Error(`GraphQL error: ${result.errors[0]?.message ?? 'Unknown error'}`);
+    }
+    return result.data?.entityModels ?? [];
+}
+/**
+ * Init command - generate local schema files from platform schemas
+ */
+export async function init(options) {
+    const credentials = await getCredentials();
+    if (!credentials) {
+        console.log('Not logged in. Run `uniformgen login` first.');
+        process.exit(1);
+    }
+    if (!credentials.selectedProject) {
+        console.log('No project selected. Run `uniformgen select-project` first.');
+        process.exit(1);
+    }
+    console.log(`Initializing schemas from project: ${credentials.selectedProject.name}\n`);
+    // Fetch remote schemas
+    console.log('Fetching schemas from platform...');
+    const schemas = await fetchRemoteSchemas(options.apiUrl, credentials.accessToken);
+    if (schemas.length === 0) {
+        console.log(chalk.yellow('No schemas found in project.'));
+        return;
+    }
+    console.log(`Found ${schemas.length} schema(s)\n`);
+    // Ensure schemas directory exists
+    const schemasDir = resolve(process.cwd(), options.schemasDir);
+    await fs.mkdir(schemasDir, { recursive: true });
+    let created = 0;
+    let skipped = 0;
+    for (const schema of schemas) {
+        const filePath = join(schemasDir, `${schema.key}.schema.ts`);
+        // Check if file exists
+        try {
+            await fs.access(filePath);
+            if (!options.overwrite) {
+                console.log(chalk.gray(`- ${schema.key}.schema.ts`) + chalk.gray(' (exists, skipped)'));
+                skipped++;
+                continue;
+            }
+        }
+        catch {
+            // File doesn't exist, continue
+        }
+        // Generate schema file
+        const content = generateSchemaFile(schema);
+        await fs.writeFile(filePath, content, 'utf-8');
+        console.log(chalk.green(`+ ${schema.key}.schema.ts`));
+        created++;
+    }
+    // Summary
+    console.log('\n' + '─'.repeat(40));
+    console.log('Summary');
+    console.log('─'.repeat(40));
+    console.log(`  Created: ${created}`);
+    console.log(`  Skipped: ${skipped}`);
+    console.log(`  Output:  ${schemasDir}`);
+}

package/dist/commands/login.d.ts

@@ -0,0 +1,9 @@
+interface LoginOptions {
+    apiUrl: string;
+}
+/**
+ * Login command - authenticate via browser OAuth
+ */
+export declare function login(options: LoginOptions): Promise<void>;
+export {};
+//# sourceMappingURL=login.d.ts.map

package/dist/commands/login.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"login.d.ts","sourceRoot":"","sources":["../../src/commands/login.ts"],"names":[],"mappings":"AAQA,UAAU,YAAY;IACpB,MAAM,EAAE,MAAM,CAAC;CAChB;AA4ED;;GAEG;AACH,wBAAsB,KAAK,CAAC,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,CAmIhE"}

package/dist/commands/login.js

@@ -0,0 +1,158 @@
+import open from 'open';
+import http from 'http';
+import crypto from 'crypto';
+import { writeCredentials, } from '../auth/credentials.js';
+/**
+ * Find an available port in a range
+ */
+async function findAvailablePort(start, end) {
+    for (let port = start; port <= end; port++) {
+        const available = await new Promise((resolve) => {
+            const server = http.createServer();
+            server.listen(port, () => {
+                server.close();
+                resolve(true);
+            });
+            server.on('error', () => resolve(false));
+        });
+        if (available) {
+            return port;
+        }
+    }
+    throw new Error(`No available ports in range ${start}-${end}`);
+}
+/**
+ * Exchange authorization code for tokens
+ */
+async function exchangeCodeForTokens(apiUrl, code, codeVerifier, redirectUri) {
+    const tokenUrl = new URL('/auth/cli/token', apiUrl);
+    const response = await fetch(tokenUrl.toString(), {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({
+            grant_type: 'authorization_code',
+            code,
+            code_verifier: codeVerifier,
+            redirect_uri: redirectUri,
+        }),
+    });
+    if (!response.ok) {
+        const error = await response.text();
+        throw new Error(`Token exchange failed: ${error}`);
+    }
+    const data = (await response.json());
+    // Map snake_case API response to camelCase
+    return {
+        accessToken: data.access_token,
+        refreshToken: data.refresh_token,
+        expiresIn: data.expires_in,
+        user: data.user,
+    };
+}
+/**
+ * Login command - authenticate via browser OAuth
+ */
+export async function login(options) {
+    console.log('Starting authentication...\n');
+    // Generate PKCE values
+    const codeVerifier = crypto.randomBytes(32).toString('base64url');
+    const codeChallenge = crypto
+        .createHash('sha256')
+        .update(codeVerifier)
+        .digest('base64url');
+    const state = crypto.randomBytes(16).toString('hex');
+    const port = await findAvailablePort(9876, 9900);
+    const redirectUri = `http://localhost:${port}/callback`;
+    // Start local server to receive callback
+    const authCode = await new Promise((resolve, reject) => {
+        const server = http.createServer((req, res) => {
+            const url = new URL(req.url, `http://localhost:${port}`);
+            if (url.pathname === '/callback') {
+                const code = url.searchParams.get('code');
+                const returnedState = url.searchParams.get('state');
+                const error = url.searchParams.get('error');
+                if (error) {
+                    res.writeHead(400, { 'Content-Type': 'text/html' });
+                    res.end(`
+            <html>
+              <body style="font-family: system-ui; text-align: center; padding: 50px;">
+                <h1>✗ Authentication failed</h1>
+                <p>${error}</p>
+                <p>You can close this window.</p>
+              </body>
+            </html>
+          `);
+                    server.close();
+                    reject(new Error(`Authentication failed: ${error}`));
+                    return;
+                }
+                if (returnedState !== state) {
+                    res.writeHead(400, { 'Content-Type': 'text/html' });
+                    res.end(`
+            <html>
+              <body style="font-family: system-ui; text-align: center; padding: 50px;">
+                <h1>✗ Security error</h1>
+                <p>Invalid state parameter. Please try again.</p>
+              </body>
+            </html>
+          `);
+                    server.close();
+                    reject(new Error('Invalid state parameter'));
+                    return;
+                }
+                // Derive admin URL from API URL (api-dev.eide.app -> admin-dev.eide.app)
+                const apiHost = new URL(options.apiUrl).host;
+                const adminHost = apiHost.replace(/^api/, 'admin');
+                const adminUrl = `https://${adminHost}`;
+                res.writeHead(200, { 'Content-Type': 'text/html' });
+                res.end(`
+          <html>
+            <head>
+              <meta http-equiv="refresh" content="2;url=${adminUrl}">
+            </head>
+            <body style="font-family: system-ui; text-align: center; padding: 50px;">
+              <h1>Authentication successful!</h1>
+              <p>Redirecting to admin panel...</p>
+              <p style="color: #666; font-size: 14px;">If not redirected, <a href="${adminUrl}">click here</a>.</p>
+            </body>
+          </html>
+        `);
+                server.close();
+                resolve(code);
+            }
+        });
+        server.listen(port);
+        // Timeout after 5 minutes
+        setTimeout(() => {
+            server.close();
+            reject(new Error('Authentication timed out after 5 minutes'));
+        }, 5 * 60 * 1000);
+        // Build auth URL and open browser
+        const authUrl = new URL('/auth/cli', options.apiUrl);
+        authUrl.searchParams.set('response_type', 'code');
+        authUrl.searchParams.set('code_challenge', codeChallenge);
+        authUrl.searchParams.set('code_challenge_method', 'S256');
+        authUrl.searchParams.set('redirect_uri', redirectUri);
+        authUrl.searchParams.set('state', state);
+        console.log('Opening browser for authentication...');
+        console.log(`If the browser doesn't open, visit: ${authUrl.toString()}\n`);
+        open(authUrl.toString()).catch(() => {
+            console.log('Could not open browser automatically.');
+            console.log(`Please visit: ${authUrl.toString()}\n`);
+        });
+    });
+    console.log('Exchanging code for tokens...');
+    // Exchange code for tokens
+    const tokens = await exchangeCodeForTokens(options.apiUrl, authCode, codeVerifier, redirectUri);
+    // Store credentials
+    const credentials = {
+        accessToken: tokens.accessToken,
+        refreshToken: tokens.refreshToken,
+        expiresAt: new Date(Date.now() + tokens.expiresIn * 1000).toISOString(),
+        user: tokens.user,
+    };
+    await writeCredentials(credentials);
+    console.log(`\n✓ Logged in as ${tokens.user.email}`);
+    console.log('\nRun `uniformgen select-project` to choose a project.');
+    process.exit(0);
+}

package/dist/commands/logout.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Logout command - clear stored credentials
+ */
+export declare function logout(): Promise<void>;
+//# sourceMappingURL=logout.d.ts.map

package/dist/commands/logout.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logout.d.ts","sourceRoot":"","sources":["../../src/commands/logout.ts"],"names":[],"mappings":"AAEA;;GAEG;AACH,wBAAsB,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC,CAU5C"}

package/dist/commands/logout.js

@@ -0,0 +1,13 @@
+import { deleteCredentials, getCredentials } from '../auth/credentials.js';
+/**
+ * Logout command - clear stored credentials
+ */
+export async function logout() {
+    const credentials = await getCredentials();
+    if (!credentials) {
+        console.log('Not logged in.');
+        return;
+    }
+    await deleteCredentials();
+    console.log(`✓ Logged out (was ${credentials.user.email})`);
+}

package/dist/commands/push.d.ts

@@ -0,0 +1,13 @@
+interface PushOptions {
+    apiUrl: string;
+    schemasDir: string;
+    pattern?: string;
+    dryRun?: boolean;
+    publish?: boolean;
+}
+/**
+ * Push command - sync local schemas to platform
+ */
+export declare function push(options: PushOptions): Promise<void>;
+export {};
+//# sourceMappingURL=push.d.ts.map

package/dist/commands/push.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"push.d.ts","sourceRoot":"","sources":["../../src/commands/push.ts"],"names":[],"mappings":"AAaA,UAAU,WAAW;IACnB,MAAM,EAAE,MAAM,CAAC;IACf,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAmVD;;GAEG;AACH,wBAAsB,IAAI,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC,CAkJ9D"}

package/dist/commands/push.js

@@ -0,0 +1,328 @@
+import chalk from 'chalk';
+import { getCredentials } from '../auth/credentials.js';
+import { loadSchemas } from '../schema/schema-loader.js';
+/**
+ * Get the internal GraphQL endpoint URL from the base API URL
+ */
+function getGraphQLEndpoint(apiUrl) {
+    const base = apiUrl.replace(/\/$/, '').replace(/\/graphql$/, '');
+    return `${base}/graphql`;
+}
+/**
+ * Fetch existing entity models from the API
+ */
+async function fetchRemoteSchemas(apiUrl, accessToken, tenantId, projectId) {
+    const response = await fetch(getGraphQLEndpoint(apiUrl), {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            Authorization: `Bearer ${accessToken}`,
+            'x-tenant-id': tenantId,
+            'x-project-id': projectId,
+        },
+        body: JSON.stringify({
+            query: `
+        query GetEntityModels {
+          entityModels(limit: 500) {
+            items {
+              id
+              key
+              metadata {
+                name
+                description
+                pluralName
+              }
+              schema
+              currentVersionId
+            }
+            total
+          }
+        }
+      `,
+        }),
+    });
+    if (!response.ok) {
+        const errorText = await response.text().catch(() => 'No response body');
+        console.error(`[Debug] API URL: ${apiUrl}`);
+        console.error(`[Debug] Response status: ${response.status}`);
+        console.error(`[Debug] Response body: ${errorText.substring(0, 500)}`);
+        throw new Error(`Failed to fetch schemas: ${response.statusText}`);
+    }
+    const result = (await response.json());
+    if (result.errors && result.errors.length > 0) {
+        console.error(`[Debug] GraphQL errors:`, JSON.stringify(result.errors, null, 2));
+        throw new Error(`GraphQL error: ${result.errors[0]?.message ?? 'Unknown error'}`);
+    }
+    const models = new Map();
+    for (const model of result.data?.entityModels?.items ?? []) {
+        models.set(model.key, model);
+    }
+    return models;
+}
+/**
+ * Create a new entity model
+ */
+async function createEntityModel(apiUrl, accessToken, tenantId, projectId, model) {
+    const response = await fetch(`${apiUrl}/graphql`, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            Authorization: `Bearer ${accessToken}`,
+            'x-tenant-id': tenantId,
+            'x-project-id': projectId,
+        },
+        body: JSON.stringify({
+            query: `
+        mutation CreateEntityModel($input: CreateEntityModelInput!) {
+          createEntityModel(input: $input) {
+            id
+            key
+            currentVersionId
+          }
+        }
+      `,
+            variables: {
+                input: {
+                    key: model.key,
+                    metadata: {
+                        name: model.name,
+                        description: model.description,
+                        pluralName: model.pluralName,
+                    },
+                    schema: {
+                        fields: model.fields,
+                    },
+                    modes: model.modes,
+                    editorMode: model.editorMode,
+                    pages: model.pages,
+                    hooks: model.hooks,
+                },
+            },
+        }),
+    });
+    if (!response.ok) {
+        throw new Error(`Failed to create schema: ${response.statusText}`);
+    }
+    const result = (await response.json());
+    if (result.errors && result.errors.length > 0) {
+        throw new Error(result.errors[0]?.message ?? 'Unknown error');
+    }
+    return {
+        id: result.data.createEntityModel.id,
+        currentVersionId: result.data.createEntityModel.currentVersionId,
+    };
+}
+/**
+ * Update an entity model schema
+ */
+async function updateEntityModelSchema(apiUrl, accessToken, tenantId, projectId, modelId, model) {
+    const response = await fetch(`${apiUrl}/graphql`, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            Authorization: `Bearer ${accessToken}`,
+            'x-tenant-id': tenantId,
+            'x-project-id': projectId,
+        },
+        body: JSON.stringify({
+            query: `
+        mutation UpdateEntityModel($id: ID!, $input: UpdateEntityModelInput!) {
+          updateEntityModel(id: $id, input: $input) {
+            id
+            key
+            currentVersionId
+          }
+        }
+      `,
+            variables: {
+                id: modelId,
+                input: {
+                    metadata: {
+                        name: model.name,
+                        description: model.description,
+                        pluralName: model.pluralName,
+                    },
+                    schema: {
+                        fields: model.fields,
+                    },
+                    modes: model.modes,
+                    editorMode: model.editorMode,
+                    pages: model.pages,
+                    hooks: model.hooks,
+                    changeDescription: `Updated via uniformgen push`,
+                },
+            },
+        }),
+    });
+    if (!response.ok) {
+        throw new Error(`Failed to update schema: ${response.statusText}`);
+    }
+    const result = (await response.json());
+    if (result.errors && result.errors.length > 0) {
+        throw new Error(result.errors[0]?.message ?? 'Unknown error');
+    }
+    return {
+        id: result.data.updateEntityModel.id,
+        currentVersionId: result.data.updateEntityModel.currentVersionId,
+    };
+}
+/**
+ * Publish an entity model schema
+ */
+async function publishEntityModelSchema(apiUrl, accessToken, tenantId, projectId, modelId, versionId) {
+    const response = await fetch(`${apiUrl}/graphql`, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            Authorization: `Bearer ${accessToken}`,
+            'x-tenant-id': tenantId,
+            'x-project-id': projectId,
+        },
+        body: JSON.stringify({
+            query: `
+        mutation PublishEntityModel($id: ID!, $versionId: ID!) {
+          publishEntityModel(id: $id, versionId: $versionId) {
+            id
+            key
+          }
+        }
+      `,
+            variables: { id: modelId, versionId },
+        }),
+    });
+    if (!response.ok) {
+        throw new Error(`Failed to publish schema: ${response.statusText}`);
+    }
+    const result = (await response.json());
+    if (result.errors && result.errors.length > 0) {
+        throw new Error(result.errors[0]?.message ?? 'Unknown error');
+    }
+}
+/**
+ * Compare two schemas and determine if they differ
+ */
+function schemasAreDifferent(local, remote) {
+    // Compare basic properties via metadata
+    if (local.name !== remote.metadata.name ||
+        local.pluralName !== remote.metadata.pluralName ||
+        local.description !== remote.metadata.description) {
+        return true;
+    }
+    // Compare fields
+    const localFields = local.fields ?? [];
+    const remoteFields = remote.schema?.fields ?? [];
+    if (localFields.length !== remoteFields.length) {
+        return true;
+    }
+    for (let i = 0; i < localFields.length; i++) {
+        const localField = localFields[i];
+        const remoteField = remoteFields[i];
+        if (localField.key !== remoteField.key ||
+            localField.type !== remoteField.type ||
+            localField.label !== remoteField.label ||
+            localField.required !== remoteField.required ||
+            localField.helpText !== remoteField.helpText ||
+            JSON.stringify(localField.options) !== JSON.stringify(remoteField.options)) {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * Push command - sync local schemas to platform
+ */
+export async function push(options) {
+    const credentials = await getCredentials();
+    if (!credentials) {
+        console.log('Not logged in. Run `uniformgen login` first.');
+        process.exit(1);
+    }
+    if (!credentials.selectedProject) {
+        console.log('No project selected. Run `uniformgen select-project` first.');
+        process.exit(1);
+    }
+    console.log(`Syncing schemas to project: ${credentials.selectedProject.name}\n`);
+    // Load local schemas
+    console.log(`Loading schemas from ${options.schemasDir}...`);
+    const localSchemas = await loadSchemas(options.schemasDir, options.pattern);
+    if (localSchemas.length === 0) {
+        console.log(chalk.yellow('No schema files found.'));
+        return;
+    }
+    console.log(`Found ${localSchemas.length} local schema(s)\n`);
+    // Fetch remote schemas
+    console.log('Fetching remote schemas...');
+    const remoteSchemas = await fetchRemoteSchemas(options.apiUrl, credentials.accessToken, credentials.selectedProject.tenantId, credentials.selectedProject.id);
+    console.log(`Found ${remoteSchemas.size} remote schema(s)\n`);
+    // Compare and sync
+    const result = {
+        created: [],
+        updated: [],
+        unchanged: [],
+        errors: [],
+    };
+    for (const local of localSchemas) {
+        const remote = remoteSchemas.get(local.key);
+        if (!remote) {
+            // Create new schema
+            if (options.dryRun) {
+                console.log(chalk.green(`+ ${local.key}`) + chalk.gray(' (would create)'));
+                result.created.push(local.key);
+            }
+            else {
+                try {
+                    const created = await createEntityModel(options.apiUrl, credentials.accessToken, credentials.selectedProject.tenantId, credentials.selectedProject.id, local);
+                    if (options.publish && created.currentVersionId) {
+                        await publishEntityModelSchema(options.apiUrl, credentials.accessToken, credentials.selectedProject.tenantId, credentials.selectedProject.id, created.id, created.currentVersionId);
+                    }
+                    console.log(chalk.green(`+ ${local.key}`) + chalk.gray(' (created)'));
+                    result.created.push(local.key);
+                }
+                catch (error) {
+                    const message = error instanceof Error ? error.message : String(error);
+                    console.log(chalk.red(`✗ ${local.key}`) + chalk.gray(` (error: ${message})`));
+                    result.errors.push({ key: local.key, error: message });
+                }
+            }
+        }
+        else if (schemasAreDifferent(local, remote)) {
+            // Update existing schema
+            if (options.dryRun) {
+                console.log(chalk.yellow(`~ ${local.key}`) + chalk.gray(' (would update)'));
+                result.updated.push(local.key);
+            }
+            else {
+                try {
+                    const updated = await updateEntityModelSchema(options.apiUrl, credentials.accessToken, credentials.selectedProject.tenantId, credentials.selectedProject.id, remote.id, local);
+                    if (options.publish && updated.currentVersionId) {
+                        await publishEntityModelSchema(options.apiUrl, credentials.accessToken, credentials.selectedProject.tenantId, credentials.selectedProject.id, updated.id, updated.currentVersionId);
+                    }
+                    console.log(chalk.yellow(`~ ${local.key}`) + chalk.gray(' (updated)'));
+                    result.updated.push(local.key);
+                }
+                catch (error) {
+                    const message = error instanceof Error ? error.message : String(error);
+                    console.log(chalk.red(`✗ ${local.key}`) + chalk.gray(` (error: ${message})`));
+                    result.errors.push({ key: local.key, error: message });
+                }
+            }
+        }
+        else {
+            console.log(chalk.gray(`= ${local.key}`) + chalk.gray(' (unchanged)'));
+            result.unchanged.push(local.key);
+        }
+    }
+    // Summary
+    console.log('\n' + '─'.repeat(40));
+    console.log('Summary');
+    console.log('─'.repeat(40));
+    console.log(`  Created:   ${result.created.length}`);
+    console.log(`  Updated:   ${result.updated.length}`);
+    console.log(`  Unchanged: ${result.unchanged.length}`);
+    if (result.errors.length > 0) {
+        console.log(`  Errors:    ${result.errors.length}`);
+    }
+    if (options.dryRun) {
+        console.log(chalk.cyan('\n(Dry run - no changes made)'));
+    }
+}

package/dist/commands/scaffold.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Scaffold Command
+ *
+ * Generates component stubs for EIDE entity models using @eide/foir-renderer.
+ * Creates type-safe components that integrate with the EntityRenderer.
+ */
+export interface ScaffoldOptions {
+    apiUrl: string;
+    componentsDir: string;
+    models?: string;
+    overwrite?: boolean;
+    framework?: 'react' | 'remix' | 'next';
+    config?: string;
+}
+/**
+ * Main scaffold function
+ */
+export declare function scaffold(options: ScaffoldOptions): Promise<void>;
+//# sourceMappingURL=scaffold.d.ts.map

package/dist/commands/scaffold.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scaffold.d.ts","sourceRoot":"","sources":["../../src/commands/scaffold.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAUH,MAAM,WAAW,eAAe;IAC9B,MAAM,EAAE,MAAM,CAAC;IACf,aAAa,EAAE,MAAM,CAAC;IACtB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,SAAS,CAAC,EAAE,OAAO,GAAG,OAAO,GAAG,MAAM,CAAC;IACvC,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAmSD;;GAEG;AACH,wBAAsB,QAAQ,CAAC,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC,IAAI,CAAC,CAsGtE"}