@parall/cli 1.34.0 → 1.36.0

package/dist/commands/external-triggers.d.ts

@@ -0,0 +1,19 @@
+import type { ExternalConnection } from '@parall/sdk';
+import type { Command } from 'commander';
+export declare const EXTERNAL_TRIGGERS_FLAG = "external-triggers";
+type ExternalTriggerFeatureFlagClient = {
+    getFeatureFlags(orgId: string): Promise<{
+        flags: Record<string, boolean | string | number>;
+    }>;
+};
+type IngressTokenOutputOptions = {
+    tokenFile?: string;
+    showToken?: boolean;
+};
+export declare function isFeatureFlagEnabled(value: boolean | string | number | undefined): boolean;
+export declare function requireExternalTriggersEnabled(client: ExternalTriggerFeatureFlagClient, orgId: string): Promise<void>;
+export declare function validateIngressTokenOutputOptions(opts: IngressTokenOutputOptions): void;
+export declare function connectionTokenOutput(connection: ExternalConnection, opts: IngressTokenOutputOptions): Promise<ExternalConnection | Record<string, unknown>>;
+export declare function registerExternalTriggerCommands(program: Command): void;
+export {};
+//# sourceMappingURL=external-triggers.d.ts.map

package/dist/commands/external-triggers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"external-triggers.d.ts","sourceRoot":"","sources":["../../src/commands/external-triggers.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAEV,kBAAkB,EAInB,MAAM,aAAa,CAAC;AACrB,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAMzC,eAAO,MAAM,sBAAsB,sBAAsB,CAAC;AAE1D,KAAK,gCAAgC,GAAG;IACtC,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC;QAAE,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,GAAG,MAAM,GAAG,MAAM,CAAC,CAAA;KAAE,CAAC,CAAC;CAC/F,CAAC;AAEF,KAAK,yBAAyB,GAAG;IAC/B,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB,CAAC;AAsDF,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,GAAG,MAAM,GAAG,SAAS,GAAG,OAAO,CAM1F;AAED,wBAAsB,8BAA8B,CAClD,MAAM,EAAE,gCAAgC,EACxC,KAAK,EAAE,MAAM,GACZ,OAAO,CAAC,IAAI,CAAC,CAKf;AAQD,wBAAgB,iCAAiC,CAAC,IAAI,EAAE,yBAAyB,GAAG,IAAI,CAKvF;AAED,wBAAsB,qBAAqB,CACzC,UAAU,EAAE,kBAAkB,EAC9B,IAAI,EAAE,yBAAyB,GAC9B,OAAO,CAAC,kBAAkB,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAqBvD;AAkBD,wBAAgB,+BAA+B,CAAC,OAAO,EAAE,OAAO,QAqZ/D"}

package/dist/commands/external-triggers.js

@@ -0,0 +1,488 @@
+import { chmod, readFile, writeFile } from 'node:fs/promises';
+import { resolveCredentials } from '../lib/client.js';
+import { printError, printJson, printRefHint, stripPrllScheme } from '../lib/output.js';
+const connectionStatuses = ['active', 'disabled'];
+const triggerStatuses = ['active', 'paused'];
+export const EXTERNAL_TRIGGERS_FLAG = 'external-triggers';
+function stripUndefined(obj) {
+    return Object.fromEntries(Object.entries(obj).filter(([, v]) => v !== undefined));
+}
+function parseIds(value, flag) {
+    const ids = value
+        .split(',')
+        .map((s) => stripPrllScheme(s.trim()))
+        .filter(Boolean);
+    if (ids.length === 0) {
+        throw new Error(`${flag} must include at least one ID.`);
+    }
+    return ids;
+}
+function parsePositiveInt(value, flag) {
+    if (value === undefined)
+        return undefined;
+    const normalized = value.trim();
+    const parsed = Number(normalized);
+    if (normalized === '' || !Number.isInteger(parsed) || parsed <= 0) {
+        throw new Error(`${flag} must be a positive integer.`);
+    }
+    return parsed;
+}
+function parseEnum(value, allowed, flag) {
+    if (value === undefined)
+        return undefined;
+    if (allowed.includes(value))
+        return value;
+    throw new Error(`${flag} must be one of: ${allowed.join(', ')}.`);
+}
+function parseJsonObject(value, flag) {
+    if (value === undefined)
+        return undefined;
+    let parsed;
+    try {
+        parsed = JSON.parse(value);
+    }
+    catch {
+        throw new Error(`${flag} must be a valid JSON object.`);
+    }
+    if (parsed === null || typeof parsed !== 'object' || Array.isArray(parsed)) {
+        throw new Error(`${flag} must be a JSON object.`);
+    }
+    return parsed;
+}
+export function isFeatureFlagEnabled(value) {
+    return (value === true ||
+        (typeof value === 'string' && value !== '') ||
+        (typeof value === 'number' && value !== 0));
+}
+export async function requireExternalTriggersEnabled(client, orgId) {
+    const res = await client.getFeatureFlags(orgId);
+    if (!isFeatureFlagEnabled(res.flags[EXTERNAL_TRIGGERS_FLAG])) {
+        throw new Error('External Triggers are disabled for this organization.');
+    }
+}
+async function resolveExternalTriggerCommandContext() {
+    const ctx = resolveCredentials();
+    await requireExternalTriggersEnabled(ctx.client, ctx.orgId);
+    return ctx;
+}
+export function validateIngressTokenOutputOptions(opts) {
+    const count = [opts.tokenFile, opts.showToken].filter(Boolean).length;
+    if (count !== 1) {
+        throw new Error('Choose exactly one token output mode: --token-file <path> or --show-token.');
+    }
+}
+export async function connectionTokenOutput(connection, opts) {
+    validateIngressTokenOutputOptions(opts);
+    if (!connection.ingress_token) {
+        throw new Error('Server did not return an ingress token.');
+    }
+    if (opts.showToken)
+        return connection;
+    if (!opts.tokenFile) {
+        throw new Error('Choose exactly one token output mode: --token-file <path> or --show-token.');
+    }
+    await writeFile(opts.tokenFile, connection.ingress_token, { mode: 0o600 });
+    await chmod(opts.tokenFile, 0o600);
+    const redacted = { ...connection };
+    delete redacted.ingress_token;
+    delete redacted.ingress_url;
+    return {
+        ...redacted,
+        ingress_token_redacted: true,
+        ingress_url_redacted: true,
+        ingress_token_file: opts.tokenFile,
+    };
+}
+async function resolveTemplate(opts) {
+    if (opts.template !== undefined && opts.templateFile !== undefined) {
+        throw new Error('Do not pass --template together with --template-file.');
+    }
+    if (opts.templateFile !== undefined) {
+        return readFile(opts.templateFile, 'utf8');
+    }
+    if (opts.template !== undefined)
+        return opts.template;
+    if (opts.required)
+        throw new Error('Provide --template or --template-file.');
+    return undefined;
+}
+export function registerExternalTriggerCommands(program) {
+    const externalTriggers = program
+        .command('external-triggers')
+        .description('Manage External Triggers (incoming platform triggers for agents)');
+    externalTriggers
+        .command('connections')
+        .description('List External Trigger Connections in the organization')
+        .option('--limit <n>', 'Maximum number of connections to return', '50')
+        .option('--cursor <cursor>', 'Pagination cursor')
+        .action(async (opts) => {
+        try {
+            const { client, orgId } = await resolveExternalTriggerCommandContext();
+            const result = await client.listExternalConnections(orgId, stripUndefined({
+                limit: parsePositiveInt(opts.limit, '--limit'),
+                cursor: opts.cursor,
+            }));
+            printJson(result);
+        }
+        catch (err) {
+            printError(err);
+        }
+    });
+    externalTriggers
+        .command('create-connection')
+        .description('Create an External Trigger Connection and return its incoming endpoint')
+        .requiredOption('--name <name>', 'Connection display name')
+        .option('--token-file <path>', 'Write the one-time token to a file with mode 0600')
+        .option('--show-token', 'Print the one-time token to stdout')
+        .action(async (opts) => {
+        try {
+            validateIngressTokenOutputOptions(opts);
+            const { client, orgId } = await resolveExternalTriggerCommandContext();
+            const result = await client.createExternalConnection(orgId, {
+                display_name: opts.name,
+            });
+            printJson(await connectionTokenOutput(result, opts));
+            printRefHint(result.id);
+        }
+        catch (err) {
+            printError(err);
+        }
+    });
+    externalTriggers
+        .command('connection')
+        .description('Get an External Trigger Connection by ID')
+        .argument('<connectionId>', 'External Trigger Connection ID')
+        .action(async (connectionId) => {
+        try {
+            const { client, orgId } = await resolveExternalTriggerCommandContext();
+            const result = await client.getExternalConnection(orgId, stripPrllScheme(connectionId));
+            printJson(result);
+        }
+        catch (err) {
+            printError(err);
+        }
+    });
+    externalTriggers
+        .command('update-connection')
+        .description('Update an External Trigger Connection')
+        .argument('<connectionId>', 'External Trigger Connection ID')
+        .option('--name <name>', 'Connection display name')
+        .option('--status <status>', 'active | disabled')
+        .action(async (connectionId, opts) => {
+        try {
+            const { client, orgId } = await resolveExternalTriggerCommandContext();
+            const patch = stripUndefined({
+                display_name: opts.name,
+                status: parseEnum(opts.status, connectionStatuses, '--status'),
+            });
+            if (Object.keys(patch).length === 0) {
+                printError(new Error('No fields to update. Provide at least one option.'));
+                return;
+            }
+            const result = await client.updateExternalConnection(orgId, stripPrllScheme(connectionId), patch);
+            printJson(result);
+        }
+        catch (err) {
+            printError(err);
+        }
+    });
+    externalTriggers
+        .command('regenerate-connection-token')
+        .description('Regenerate a connection ingress token; old webhook URLs stop working')
+        .argument('<connectionId>', 'External Trigger Connection ID')
+        .option('--token-file <path>', 'Write the one-time token to a file with mode 0600')
+        .option('--show-token', 'Print the one-time token to stdout')
+        .action(async (connectionId, opts) => {
+        try {
+            validateIngressTokenOutputOptions(opts);
+            const { client, orgId } = await resolveExternalTriggerCommandContext();
+            const result = await client.regenerateExternalConnectionIngressToken(orgId, stripPrllScheme(connectionId));
+            printJson(await connectionTokenOutput(result, opts));
+            printRefHint(result.id, 'Regenerated');
+        }
+        catch (err) {
+            printError(err);
+        }
+    });
+    externalTriggers
+        .command('delete-connection')
+        .description('Archive an External Trigger Connection')
+        .argument('<connectionId>', 'External Trigger Connection ID')
+        .action(async (connectionId) => {
+        try {
+            const { client, orgId } = await resolveExternalTriggerCommandContext();
+            await client.deleteExternalConnection(orgId, stripPrllScheme(connectionId));
+            printJson({ ok: true });
+        }
+        catch (err) {
+            printError(err);
+        }
+    });
+    externalTriggers
+        .command('schema')
+        .description('Inspect CEL/template variables supported by a connection')
+        .argument('<connectionId>', 'External Trigger Connection ID')
+        .action(async (connectionId) => {
+        try {
+            const { client, orgId } = await resolveExternalTriggerCommandContext();
+            const result = await client.getExternalTriggerSchema(orgId, stripPrllScheme(connectionId));
+            printJson(result);
+        }
+        catch (err) {
+            printError(err);
+        }
+    });
+    externalTriggers
+        .command('list')
+        .description('List External Triggers in the organization')
+        .option('--connection <connectionId>', 'Filter by External Trigger Connection ID')
+        .option('--creator-id <id>', 'Filter by creator user ID')
+        .option('--limit <n>', 'Maximum number of triggers to return', '50')
+        .option('--cursor <cursor>', 'Pagination cursor')
+        .action(async (opts) => {
+        try {
+            const { client, orgId } = await resolveExternalTriggerCommandContext();
+            const result = await client.listExternalTriggers(orgId, stripUndefined({
+                connection_id: opts.connection ? stripPrllScheme(opts.connection) : undefined,
+                creator_id: opts.creatorId ? stripPrllScheme(opts.creatorId) : undefined,
+                limit: parsePositiveInt(opts.limit, '--limit'),
+                cursor: opts.cursor,
+            }));
+            printJson(result);
+        }
+        catch (err) {
+            printError(err);
+        }
+    });
+    externalTriggers
+        .command('create')
+        .description('Create an External Trigger targeting one or more agents')
+        .requiredOption('--connection <connectionId>', 'External Trigger Connection ID')
+        .requiredOption('--name <name>', 'Trigger name')
+        .requiredOption('--target-ids <ids>', 'Comma-separated target agent user IDs')
+        .option('--description <text>', 'Human-facing trigger description')
+        .option('--attached-to-uri <uri>', 'Attach to a prll:// resource URI')
+        .option('--filter <expr>', 'CEL filter expression', 'true')
+        .option('--filter-metadata-json <json>', 'JSON object with UI/display metadata for the filter')
+        .option('--template <text>', 'Liquid template for the agent input body')
+        .option('--template-file <path>', 'Read the Liquid template from a file')
+        .option('--max-runs <n>', 'Maximum delivered runs before the trigger auto-archives')
+        .option('--expires-at <ts>', 'Expiration time (RFC3339)')
+        .option('--client-context-json <json>', 'JSON object stored with the trigger')
+        .action(async (opts) => {
+        try {
+            const { client, orgId } = await resolveExternalTriggerCommandContext();
+            const agentInputTemplate = await resolveTemplate({ ...opts, required: true });
+            const data = {
+                connection_id: stripPrllScheme(opts.connection),
+                name: opts.name,
+                target_agent_ids: parseIds(opts.targetIds, '--target-ids'),
+                filter_expr: opts.filter,
+                agent_input_template: agentInputTemplate ?? '',
+                ...stripUndefined({
+                    description: opts.description,
+                    attached_to_uri: opts.attachedToUri,
+                    filter_display_metadata: parseJsonObject(opts.filterMetadataJson, '--filter-metadata-json'),
+                    max_runs: parsePositiveInt(opts.maxRuns, '--max-runs'),
+                    expires_at: opts.expiresAt,
+                    client_context: parseJsonObject(opts.clientContextJson, '--client-context-json'),
+                }),
+            };
+            const result = await client.createExternalTrigger(orgId, data);
+            printJson(result);
+            printRefHint(result.id);
+        }
+        catch (err) {
+            printError(err);
+        }
+    });
+    externalTriggers
+        .command('get')
+        .description('Get an External Trigger by ID')
+        .argument('<triggerId>', 'External Trigger ID')
+        .action(async (triggerId) => {
+        try {
+            const { client, orgId } = await resolveExternalTriggerCommandContext();
+            const result = await client.getExternalTrigger(orgId, stripPrllScheme(triggerId));
+            printJson(result);
+        }
+        catch (err) {
+            printError(err);
+        }
+    });
+    externalTriggers
+        .command('update')
+        .description('Update an External Trigger')
+        .argument('<triggerId>', 'External Trigger ID')
+        .option('--name <name>', 'Trigger name')
+        .option('--description <text>', 'Human-facing trigger description')
+        .option('--status <status>', 'active | paused')
+        .option('--target-ids <ids>', 'Comma-separated target agent user IDs')
+        .option('--attached-to-uri <uri>', 'Attach to a prll:// resource URI')
+        .option('--clear-attached-to', 'Explicitly clear attached_to_uri')
+        .option('--filter <expr>', 'CEL filter expression')
+        .option('--filter-metadata-json <json>', 'JSON object with UI/display metadata for the filter')
+        .option('--template <text>', 'Liquid template for the agent input body')
+        .option('--template-file <path>', 'Read the Liquid template from a file')
+        .option('--max-runs <n>', 'Maximum delivered runs before the trigger auto-archives')
+        .option('--clear-max-runs', 'Explicitly clear max_runs')
+        .option('--expires-at <ts>', 'Expiration time (RFC3339)')
+        .option('--clear-expires-at', 'Explicitly clear expires_at')
+        .option('--client-context-json <json>', 'JSON object stored with the trigger')
+        .action(async (triggerId, opts) => {
+        try {
+            const { client, orgId } = await resolveExternalTriggerCommandContext();
+            const conflicts = [
+                [opts.attachedToUri, opts.clearAttachedTo, '--attached-to-uri', '--clear-attached-to'],
+                [opts.maxRuns, opts.clearMaxRuns, '--max-runs', '--clear-max-runs'],
+                [opts.expiresAt, opts.clearExpiresAt, '--expires-at', '--clear-expires-at'],
+            ];
+            for (const [value, clear, valueFlag, clearFlag] of conflicts) {
+                if (value !== undefined && clear) {
+                    printError(new Error(`Do not pass ${valueFlag} together with ${clearFlag}.`));
+                    return;
+                }
+            }
+            const agentInputTemplate = await resolveTemplate(opts);
+            const patch = stripUndefined({
+                name: opts.name,
+                description: opts.description,
+                status: parseEnum(opts.status, triggerStatuses, '--status'),
+                target_agent_ids: opts.targetIds !== undefined ? parseIds(opts.targetIds, '--target-ids') : undefined,
+                attached_to_uri: opts.attachedToUri,
+                attached_to_uri_clear: opts.clearAttachedTo || undefined,
+                filter_expr: opts.filter,
+                filter_display_metadata: parseJsonObject(opts.filterMetadataJson, '--filter-metadata-json'),
+                agent_input_template: agentInputTemplate,
+                max_runs: parsePositiveInt(opts.maxRuns, '--max-runs'),
+                max_runs_clear: opts.clearMaxRuns || undefined,
+                expires_at: opts.expiresAt,
+                expires_at_clear: opts.clearExpiresAt || undefined,
+                client_context: parseJsonObject(opts.clientContextJson, '--client-context-json'),
+            });
+            if (Object.keys(patch).length === 0) {
+                printError(new Error('No fields to update. Provide at least one option.'));
+                return;
+            }
+            const result = await client.updateExternalTrigger(orgId, stripPrllScheme(triggerId), patch);
+            printJson(result);
+        }
+        catch (err) {
+            printError(err);
+        }
+    });
+    externalTriggers
+        .command('pause')
+        .description('Pause an External Trigger')
+        .argument('<triggerId>', 'External Trigger ID')
+        .action(async (triggerId) => {
+        try {
+            const { client, orgId } = await resolveExternalTriggerCommandContext();
+            const result = await client.updateExternalTrigger(orgId, stripPrllScheme(triggerId), {
+                status: 'paused',
+            });
+            printJson(result);
+        }
+        catch (err) {
+            printError(err);
+        }
+    });
+    externalTriggers
+        .command('resume')
+        .description('Resume a paused External Trigger')
+        .argument('<triggerId>', 'External Trigger ID')
+        .action(async (triggerId) => {
+        try {
+            const { client, orgId } = await resolveExternalTriggerCommandContext();
+            const result = await client.updateExternalTrigger(orgId, stripPrllScheme(triggerId), {
+                status: 'active',
+            });
+            printJson(result);
+        }
+        catch (err) {
+            printError(err);
+        }
+    });
+    externalTriggers
+        .command('delete')
+        .description('Archive an External Trigger')
+        .argument('<triggerId>', 'External Trigger ID')
+        .action(async (triggerId) => {
+        try {
+            const { client, orgId } = await resolveExternalTriggerCommandContext();
+            await client.deleteExternalTrigger(orgId, stripPrllScheme(triggerId));
+            printJson({ ok: true });
+        }
+        catch (err) {
+            printError(err);
+        }
+    });
+    externalTriggers
+        .command('runs')
+        .description('List run history for an External Trigger')
+        .argument('<triggerId>', 'External Trigger ID')
+        .option('--limit <n>', 'Maximum number of runs to return', '50')
+        .option('--cursor <cursor>', 'Pagination cursor')
+        .action(async (triggerId, opts) => {
+        try {
+            const { client, orgId } = await resolveExternalTriggerCommandContext();
+            const result = await client.listExternalTriggerRuns(orgId, stripUndefined({
+                trigger_id: stripPrllScheme(triggerId),
+                limit: parsePositiveInt(opts.limit, '--limit'),
+                cursor: opts.cursor,
+            }));
+            printJson(result);
+        }
+        catch (err) {
+            printError(err);
+        }
+    });
+    externalTriggers
+        .command('run')
+        .description('Get a single External Trigger run')
+        .argument('<runId>', 'External Trigger Run ID (xrn_...)')
+        .action(async (runId) => {
+        try {
+            const { client, orgId } = await resolveExternalTriggerCommandContext();
+            const result = await client.getExternalTriggerRun(orgId, stripPrllScheme(runId));
+            printJson(result);
+        }
+        catch (err) {
+            printError(err);
+        }
+    });
+    externalTriggers
+        .command('events')
+        .description('List incoming events received by External Trigger Connections')
+        .option('--connection <connectionId>', 'Filter by External Trigger Connection ID')
+        .option('--limit <n>', 'Maximum number of events to return', '50')
+        .option('--cursor <cursor>', 'Pagination cursor')
+        .action(async (opts) => {
+        try {
+            const { client, orgId } = await resolveExternalTriggerCommandContext();
+            const result = await client.listExternalIngressEvents(orgId, stripUndefined({
+                connection_id: opts.connection ? stripPrllScheme(opts.connection) : undefined,
+                limit: parsePositiveInt(opts.limit, '--limit'),
+                cursor: opts.cursor,
+            }));
+            printJson(result);
+        }
+        catch (err) {
+            printError(err);
+        }
+    });
+    externalTriggers
+        .command('event')
+        .description('Get a single incoming event by ID')
+        .argument('<eventId>', 'External Trigger Event ID (xin_...)')
+        .action(async (eventId) => {
+        try {
+            const { client, orgId } = await resolveExternalTriggerCommandContext();
+            const result = await client.getExternalIngressEvent(orgId, stripPrllScheme(eventId));
+            printJson(result);
+        }
+        catch (err) {
+            printError(err);
+        }
+    });
+}

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

@@ -1 +1 @@
-{"version":3,"file":"tasks.d.ts","sourceRoot":"","sources":["../../src/commands/tasks.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAQpC,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,OAAO,QAoSpD"}
+{"version":3,"file":"tasks.d.ts","sourceRoot":"","sources":["../../src/commands/tasks.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAQpC,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,OAAO,QAqTpD"}

package/dist/commands/tasks.js

@@ -148,6 +148,21 @@ export function registerTaskCommands(program) {
             printError(err);
         }
     });
+    tasks
+        .command('assigned')
+        .description("List pending tasks (todo + in_progress) on a member's plate, including subtasks assigned to them")
+        .argument('[memberId]', 'Member user ID (defaults to the authenticated user)')
+        .action(async (memberId) => {
+        try {
+            const { client, orgId } = resolveCredentials();
+            const targetId = memberId ? stripPrllScheme(memberId) : (await client.getMe()).id;
+            const result = await client.getMemberTasksAll(orgId, targetId);
+            printJson(result);
+        }
+        catch (err) {
+            printError(err);
+        }
+    });
     // ---- Comments subgroup ----
     const comments = tasks.command('comments').description('Manage task comments');
     comments

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

@@ -1 +1 @@
-{"version":3,"file":"wiki.d.ts","sourceRoot":"","sources":["../../src/commands/wiki.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAwBpC,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,OAAO,QAq2BpD"}
+{"version":3,"file":"wiki.d.ts","sourceRoot":"","sources":["../../src/commands/wiki.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAyBpC,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,OAAO,QAk/BpD"}