synarcx 0.1.0

package/dist/commands/workflow/new-change.d.ts

@@ -0,0 +1,11 @@
+/**
+ * New Change Command
+ *
+ * Creates a new change directory with optional description and schema.
+ */
+export interface NewChangeOptions {
+    description?: string;
+    schema?: string;
+}
+export declare function newChangeCommand(name: string | undefined, options: NewChangeOptions): Promise<void>;
+//# sourceMappingURL=new-change.d.ts.map

package/dist/commands/workflow/new-change.js

@@ -0,0 +1,45 @@
+/**
+ * New Change Command
+ *
+ * Creates a new change directory with optional description and schema.
+ */
+import ora from 'ora';
+import path from 'path';
+import { createChange, validateChangeName } from '../../utils/change-utils.js';
+import { validateSchemaExists } from './shared.js';
+import { SYNSPEC_DIR_NAME } from '../../core/config.js';
+// -----------------------------------------------------------------------------
+// Command Implementation
+// -----------------------------------------------------------------------------
+export async function newChangeCommand(name, options) {
+    if (!name) {
+        throw new Error('Missing required argument <name>');
+    }
+    const validation = validateChangeName(name);
+    if (!validation.valid) {
+        throw new Error(validation.error);
+    }
+    const projectRoot = process.cwd();
+    // Validate schema if provided
+    if (options.schema) {
+        validateSchemaExists(options.schema, projectRoot);
+    }
+    const schemaDisplay = options.schema ? ` with schema '${options.schema}'` : '';
+    const spinner = ora(`Creating change '${name}'${schemaDisplay}...`).start();
+    try {
+        const result = await createChange(projectRoot, name, { schema: options.schema });
+        // If description provided, create README.md with description
+        if (options.description) {
+            const { promises: fs } = await import('fs');
+            const changeDir = path.join(projectRoot, SYNSPEC_DIR_NAME, 'changes', name);
+            const readmePath = path.join(changeDir, 'README.md');
+            await fs.writeFile(readmePath, `# ${name}\n\n${options.description}\n`, 'utf-8');
+        }
+        spinner.succeed(`Created change '${name}' at synspec/changes/${name}/ (schema: ${result.schema})`);
+    }
+    catch (error) {
+        spinner.fail(`Failed to create change '${name}'`);
+        throw error;
+    }
+}
+//# sourceMappingURL=new-change.js.map

package/dist/commands/workflow/schemas.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Schemas Command
+ *
+ * Lists available workflow schemas with descriptions.
+ */
+export interface SchemasOptions {
+    json?: boolean;
+}
+export declare function schemasCommand(options: SchemasOptions): Promise<void>;
+//# sourceMappingURL=schemas.d.ts.map

package/dist/commands/workflow/schemas.js

@@ -0,0 +1,34 @@
+/**
+ * Schemas Command
+ *
+ * Lists available workflow schemas with descriptions.
+ */
+import chalk from 'chalk';
+import { listSchemasWithInfo } from '../../core/artifact-graph/index.js';
+// -----------------------------------------------------------------------------
+// Command Implementation
+// -----------------------------------------------------------------------------
+export async function schemasCommand(options) {
+    const projectRoot = process.cwd();
+    const schemas = listSchemasWithInfo(projectRoot);
+    if (options.json) {
+        console.log(JSON.stringify(schemas, null, 2));
+        return;
+    }
+    console.log('Available schemas:');
+    console.log();
+    for (const schema of schemas) {
+        let sourceLabel = '';
+        if (schema.source === 'project') {
+            sourceLabel = chalk.cyan(' (project)');
+        }
+        else if (schema.source === 'user') {
+            sourceLabel = chalk.dim(' (user override)');
+        }
+        console.log(`  ${chalk.bold(schema.name)}${sourceLabel}`);
+        console.log(`    ${schema.description}`);
+        console.log(`    Artifacts: ${schema.artifacts.join(' → ')}`);
+        console.log();
+    }
+}
+//# sourceMappingURL=schemas.js.map

package/dist/commands/workflow/shared.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Shared Types and Utilities for Artifact Workflow Commands
+ *
+ * This module contains types, constants, and validation helpers used across
+ * multiple artifact workflow commands.
+ */
+export interface TaskItem {
+    id: string;
+    description: string;
+    done: boolean;
+}
+export interface ApplyInstructions {
+    changeName: string;
+    changeDir: string;
+    schemaName: string;
+    contextFiles: Record<string, string[]>;
+    progress: {
+        total: number;
+        complete: number;
+        remaining: number;
+    };
+    tasks: TaskItem[];
+    state: 'blocked' | 'all_done' | 'ready';
+    missingArtifacts?: string[];
+    instruction: string;
+}
+export declare const DEFAULT_SCHEMA = "synarcx";
+/**
+ * Checks if color output is disabled via NO_COLOR env or --no-color flag.
+ */
+export declare function isColorDisabled(): boolean;
+/**
+ * Gets the color function based on status.
+ */
+export declare function getStatusColor(status: 'done' | 'ready' | 'blocked'): (text: string) => string;
+/**
+ * Gets the status indicator for an artifact.
+ */
+export declare function getStatusIndicator(status: 'done' | 'ready' | 'blocked'): string;
+/**
+ * Returns the list of available change directory names under synspec/changes/.
+ * Excludes the archive directory and hidden directories.
+ */
+export declare function getAvailableChanges(projectRoot: string): Promise<string[]>;
+/**
+ * Validates that a change exists and returns available changes if not.
+ * Checks directory existence directly to support scaffolded changes (without proposal.md).
+ */
+export declare function validateChangeExists(changeName: string | undefined, projectRoot: string): Promise<string>;
+/**
+ * Validates that a schema exists and returns available schemas if not.
+ *
+ * @param schemaName - The schema name to validate
+ * @param projectRoot - Optional project root for project-local schema resolution
+ */
+export declare function validateSchemaExists(schemaName: string, projectRoot?: string): string;
+//# sourceMappingURL=shared.d.ts.map

package/dist/commands/workflow/shared.js

@@ -0,0 +1,117 @@
+/**
+ * Shared Types and Utilities for Artifact Workflow Commands
+ *
+ * This module contains types, constants, and validation helpers used across
+ * multiple artifact workflow commands.
+ */
+import chalk from 'chalk';
+import path from 'path';
+import * as fs from 'fs';
+import { getSchemaDir, listSchemas } from '../../core/artifact-graph/index.js';
+import { validateChangeName } from '../../utils/change-utils.js';
+import { SYNSPEC_DIR_NAME } from '../../core/config.js';
+// -----------------------------------------------------------------------------
+// Constants
+// -----------------------------------------------------------------------------
+export const DEFAULT_SCHEMA = 'synarcx';
+// -----------------------------------------------------------------------------
+// Utility Functions
+// -----------------------------------------------------------------------------
+/**
+ * Checks if color output is disabled via NO_COLOR env or --no-color flag.
+ */
+export function isColorDisabled() {
+    return process.env.NO_COLOR === '1' || process.env.NO_COLOR === 'true';
+}
+/**
+ * Gets the color function based on status.
+ */
+export function getStatusColor(status) {
+    if (isColorDisabled()) {
+        return (text) => text;
+    }
+    switch (status) {
+        case 'done':
+            return chalk.green;
+        case 'ready':
+            return chalk.yellow;
+        case 'blocked':
+            return chalk.red;
+    }
+}
+/**
+ * Gets the status indicator for an artifact.
+ */
+export function getStatusIndicator(status) {
+    const color = getStatusColor(status);
+    switch (status) {
+        case 'done':
+            return color('[x]');
+        case 'ready':
+            return color('[ ]');
+        case 'blocked':
+            return color('[-]');
+    }
+}
+/**
+ * Returns the list of available change directory names under synspec/changes/.
+ * Excludes the archive directory and hidden directories.
+ */
+export async function getAvailableChanges(projectRoot) {
+    const changesPath = path.join(projectRoot, SYNSPEC_DIR_NAME, 'changes');
+    try {
+        const entries = await fs.promises.readdir(changesPath, { withFileTypes: true });
+        return entries
+            .filter((e) => e.isDirectory() && e.name !== 'archive' && !e.name.startsWith('.'))
+            .map((e) => e.name);
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return [];
+        throw error;
+    }
+}
+/**
+ * Validates that a change exists and returns available changes if not.
+ * Checks directory existence directly to support scaffolded changes (without proposal.md).
+ */
+export async function validateChangeExists(changeName, projectRoot) {
+    if (!changeName) {
+        const available = await getAvailableChanges(projectRoot);
+        if (available.length === 0) {
+            throw new Error('No changes found. Create one with: synarcx new change <name>');
+        }
+        throw new Error(`Missing required option --change. Available changes:\n  ${available.join('\n  ')}`);
+    }
+    // Validate change name format to prevent path traversal
+    const nameValidation = validateChangeName(changeName);
+    if (!nameValidation.valid) {
+        throw new Error(`Invalid change name '${changeName}': ${nameValidation.error}`);
+    }
+    // Check directory existence directly
+    const changePath = path.join(projectRoot, SYNSPEC_DIR_NAME, 'changes', changeName);
+    const exists = fs.existsSync(changePath) && fs.statSync(changePath).isDirectory();
+    if (!exists) {
+        const available = await getAvailableChanges(projectRoot);
+        if (available.length === 0) {
+            throw new Error(`Change '${changeName}' not found. No changes exist. Create one with: synarcx new change <name>`);
+        }
+        throw new Error(`Change '${changeName}' not found. Available changes:\n  ${available.join('\n  ')}`);
+    }
+    return changeName;
+}
+/**
+ * Validates that a schema exists and returns available schemas if not.
+ *
+ * @param schemaName - The schema name to validate
+ * @param projectRoot - Optional project root for project-local schema resolution
+ */
+export function validateSchemaExists(schemaName, projectRoot) {
+    const schemaDir = getSchemaDir(schemaName, projectRoot);
+    if (!schemaDir) {
+        const availableSchemas = listSchemas(projectRoot);
+        throw new Error(`Schema '${schemaName}' not found. Available schemas:\n  ${availableSchemas.join('\n  ')}`);
+    }
+    return schemaName;
+}
+//# sourceMappingURL=shared.js.map

package/dist/commands/workflow/status.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Status Command
+ *
+ * Displays artifact completion status for a change.
+ */
+import { type ChangeStatus } from '../../core/artifact-graph/index.js';
+export interface StatusOptions {
+    change?: string;
+    schema?: string;
+    json?: boolean;
+}
+export declare function statusCommand(options: StatusOptions): Promise<void>;
+export declare function printStatusText(status: ChangeStatus): void;
+//# sourceMappingURL=status.d.ts.map

package/dist/commands/workflow/status.js

@@ -0,0 +1,75 @@
+/**
+ * Status Command
+ *
+ * Displays artifact completion status for a change.
+ */
+import ora from 'ora';
+import chalk from 'chalk';
+import { loadChangeContext, formatChangeStatus, } from '../../core/artifact-graph/index.js';
+import { validateChangeExists, validateSchemaExists, getAvailableChanges, getStatusIndicator, getStatusColor, } from './shared.js';
+// -----------------------------------------------------------------------------
+// Command Implementation
+// -----------------------------------------------------------------------------
+export async function statusCommand(options) {
+    const spinner = options.json ? undefined : ora('Loading change status...').start();
+    try {
+        const projectRoot = process.cwd();
+        // Handle no-changes case gracefully — status is informational,
+        // so "no changes" is a valid state, not an error.
+        if (!options.change) {
+            const available = await getAvailableChanges(projectRoot);
+            if (available.length === 0) {
+                spinner?.stop();
+                if (options.json) {
+                    console.log(JSON.stringify({ changes: [], message: 'No active changes.' }, null, 2));
+                    return;
+                }
+                console.log('No active changes. Create one with: synarcx new change <name>');
+                return;
+            }
+            // Changes exist but --change not provided
+            spinner?.stop();
+            throw new Error(`Missing required option --change. Available changes:\n  ${available.join('\n  ')}`);
+        }
+        const changeName = await validateChangeExists(options.change, projectRoot);
+        // Validate schema if explicitly provided
+        if (options.schema) {
+            validateSchemaExists(options.schema, projectRoot);
+        }
+        // loadChangeContext will auto-detect schema from metadata if not provided
+        const context = loadChangeContext(projectRoot, changeName, options.schema);
+        const status = formatChangeStatus(context);
+        spinner?.stop();
+        if (options.json) {
+            console.log(JSON.stringify(status, null, 2));
+            return;
+        }
+        printStatusText(status);
+    }
+    catch (error) {
+        spinner?.stop();
+        throw error;
+    }
+}
+export function printStatusText(status) {
+    const doneCount = status.artifacts.filter((a) => a.status === 'done').length;
+    const total = status.artifacts.length;
+    console.log(`Change: ${status.changeName}`);
+    console.log(`Schema: ${status.schemaName}`);
+    console.log(`Progress: ${doneCount}/${total} artifacts complete`);
+    console.log();
+    for (const artifact of status.artifacts) {
+        const indicator = getStatusIndicator(artifact.status);
+        const color = getStatusColor(artifact.status);
+        let line = `${indicator} ${artifact.id}`;
+        if (artifact.status === 'blocked' && artifact.missingDeps && artifact.missingDeps.length > 0) {
+            line += color(` (blocked by: ${artifact.missingDeps.join(', ')})`);
+        }
+        console.log(line);
+    }
+    if (status.isComplete) {
+        console.log();
+        console.log(chalk.green('All artifacts complete!'));
+    }
+}
+//# sourceMappingURL=status.js.map

package/dist/commands/workflow/templates.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Templates Command
+ *
+ * Shows resolved template paths for all artifacts in a schema.
+ */
+export interface TemplatesOptions {
+    schema?: string;
+    json?: boolean;
+}
+export interface TemplateInfo {
+    artifactId: string;
+    templatePath: string;
+    source: 'project' | 'user' | 'package';
+}
+export declare function templatesCommand(options: TemplatesOptions): Promise<void>;
+//# sourceMappingURL=templates.d.ts.map

package/dist/commands/workflow/templates.js

@@ -0,0 +1,69 @@
+/**
+ * Templates Command
+ *
+ * Shows resolved template paths for all artifacts in a schema.
+ */
+import ora from 'ora';
+import path from 'path';
+import { resolveSchema, getSchemaDir, ArtifactGraph, } from '../../core/artifact-graph/index.js';
+import { FileSystemUtils } from '../../utils/file-system.js';
+import { validateSchemaExists, DEFAULT_SCHEMA } from './shared.js';
+// -----------------------------------------------------------------------------
+// Command Implementation
+// -----------------------------------------------------------------------------
+export async function templatesCommand(options) {
+    const spinner = options.json ? undefined : ora('Loading templates...').start();
+    try {
+        const projectRoot = process.cwd();
+        const schemaName = validateSchemaExists(options.schema ?? DEFAULT_SCHEMA, projectRoot);
+        const schema = resolveSchema(schemaName, projectRoot);
+        const graph = ArtifactGraph.fromSchema(schema);
+        const schemaDir = getSchemaDir(schemaName, projectRoot);
+        // Determine the source (project, user, or package)
+        const { getUserSchemasDir, getProjectSchemasDir, } = await import('../../core/artifact-graph/resolver.js');
+        const projectSchemasDir = getProjectSchemasDir(projectRoot);
+        const userSchemasDir = getUserSchemasDir();
+        // Determine source by checking if schemaDir is inside each base directory
+        // Using path.relative is more robust than startsWith for path comparisons
+        const isInsideDir = (child, parent) => {
+            const relative = path.relative(parent, child);
+            return !relative.startsWith('..') && !path.isAbsolute(relative);
+        };
+        let source;
+        if (isInsideDir(schemaDir, projectSchemasDir)) {
+            source = 'project';
+        }
+        else if (isInsideDir(schemaDir, userSchemasDir)) {
+            source = 'user';
+        }
+        else {
+            source = 'package';
+        }
+        const templates = graph.getAllArtifacts().map((artifact) => ({
+            artifactId: artifact.id,
+            templatePath: FileSystemUtils.canonicalizeExistingPath(path.join(schemaDir, 'templates', artifact.template)),
+            source,
+        }));
+        spinner?.stop();
+        if (options.json) {
+            const output = {};
+            for (const t of templates) {
+                output[t.artifactId] = { path: t.templatePath, source: t.source };
+            }
+            console.log(JSON.stringify(output, null, 2));
+            return;
+        }
+        console.log(`Schema: ${schemaName}`);
+        console.log(`Source: ${source}`);
+        console.log();
+        for (const t of templates) {
+            console.log(`${t.artifactId}:`);
+            console.log(`  ${t.templatePath}`);
+        }
+    }
+    catch (error) {
+        spinner?.stop();
+        throw error;
+    }
+}
+//# sourceMappingURL=templates.js.map

package/dist/commands/workspace/open.d.ts

@@ -0,0 +1,29 @@
+import { spawn as nodeSpawn } from 'node:child_process';
+import { WorkspaceLocalState, WorkspacePreferredOpener, WorkspaceSharedState, resolveWorkspaceOpenLinks } from '../../core/workspace/index.js';
+import { SelectedWorkspace } from './types.js';
+export declare const WORKSPACE_OPEN_MINIMAL_PROMPT = "Open this synarcx workspace.";
+export interface WorkspaceOpenState {
+    sharedState: WorkspaceSharedState;
+    localState: WorkspaceLocalState;
+    codeWorkspacePath: string;
+}
+export interface WorkspaceOpenLaunchCommand {
+    executable: string;
+    args: string[];
+    cwd: string;
+    openerLabel: string;
+}
+export type WorkspaceOpenSpawn = typeof nodeSpawn;
+export interface WorkspaceOpenLaunchOptions {
+    spawn?: WorkspaceOpenSpawn;
+    isExecutableAvailable?: (executable: string) => boolean;
+}
+export declare function readWorkspaceOpenState(selected: SelectedWorkspace): Promise<WorkspaceOpenState>;
+export declare function buildWorkspaceOpenLaunchCommand(opener: WorkspacePreferredOpener, workspaceRoot: string, codeWorkspacePath: string, linkedPaths: string[]): WorkspaceOpenLaunchCommand;
+export declare function assertWorkspaceOpenerAvailable(opener: WorkspacePreferredOpener, codeWorkspacePath: string, isExecutableAvailable?: (executable: string) => boolean): void;
+export declare function buildWorkspaceOpenCommandForState(opener: WorkspacePreferredOpener, workspaceRoot: string, state: WorkspaceOpenState): Promise<{
+    command: WorkspaceOpenLaunchCommand;
+    skipped: Awaited<ReturnType<typeof resolveWorkspaceOpenLinks>>['skipped'];
+}>;
+export declare function launchWorkspaceOpenCommand(command: WorkspaceOpenLaunchCommand, options?: WorkspaceOpenLaunchOptions): Promise<void>;
+//# sourceMappingURL=open.d.ts.map

package/dist/commands/workspace/open.js

@@ -0,0 +1,84 @@
+import { createRequire } from 'node:module';
+import { getWorkspaceCodeWorkspacePath, getWorkspaceOpenerExecutable, getWorkspaceOpenerLabel, isWorkspaceExecutableAvailable, readWorkspaceLocalState, readWorkspaceSharedState, resolveWorkspaceOpenLinks, writeWorkspaceCodeWorkspaceFile, } from '../../core/workspace/index.js';
+import { WorkspaceCliError, asErrorMessage } from './types.js';
+export const WORKSPACE_OPEN_MINIMAL_PROMPT = 'Open this synarcx workspace.';
+const require = createRequire(import.meta.url);
+const spawn = require('cross-spawn');
+export async function readWorkspaceOpenState(selected) {
+    const sharedState = await readWorkspaceSharedState(selected.root);
+    const localState = await readWorkspaceLocalState(selected.root);
+    return {
+        sharedState,
+        localState,
+        codeWorkspacePath: getWorkspaceCodeWorkspacePath(selected.root, sharedState.name),
+    };
+}
+export function buildWorkspaceOpenLaunchCommand(opener, workspaceRoot, codeWorkspacePath, linkedPaths) {
+    const executable = getWorkspaceOpenerExecutable(opener);
+    const openerLabel = getWorkspaceOpenerLabel(opener);
+    if (opener.kind === 'editor' || opener.id === 'github-copilot') {
+        return {
+            executable,
+            args: [codeWorkspacePath],
+            cwd: workspaceRoot,
+            openerLabel,
+        };
+    }
+    return {
+        executable,
+        args: [
+            ...linkedPaths.flatMap((linkedPath) => ['--add-dir', linkedPath]),
+            WORKSPACE_OPEN_MINIMAL_PROMPT,
+        ],
+        cwd: workspaceRoot,
+        openerLabel,
+    };
+}
+export function assertWorkspaceOpenerAvailable(opener, codeWorkspacePath, isExecutableAvailable = isWorkspaceExecutableAvailable) {
+    const executable = getWorkspaceOpenerExecutable(opener);
+    if (isExecutableAvailable(executable)) {
+        return;
+    }
+    const openerLabel = getWorkspaceOpenerLabel(opener);
+    const manualPath = executable === 'code'
+        ? ` You can open the workspace file manually: ${codeWorkspacePath}`
+        : '';
+    throw new WorkspaceCliError(`${openerLabel} requires '${executable}', but '${executable}' was not found on PATH.${manualPath}`, 'workspace_opener_unavailable', {
+        target: 'workspace.opener',
+        fix: `Install '${executable}' or choose another opener.`,
+    });
+}
+export async function buildWorkspaceOpenCommandForState(opener, workspaceRoot, state) {
+    const openLinks = await resolveWorkspaceOpenLinks(state.sharedState, state.localState);
+    await writeWorkspaceCodeWorkspaceFile(state.codeWorkspacePath, openLinks.links);
+    return {
+        command: buildWorkspaceOpenLaunchCommand(opener, workspaceRoot, state.codeWorkspacePath, openLinks.links.map((link) => link.path)),
+        skipped: openLinks.skipped,
+    };
+}
+export async function launchWorkspaceOpenCommand(command, options = {}) {
+    const spawnCommand = options.spawn ?? spawn;
+    await new Promise((resolve, reject) => {
+        const child = spawnCommand(command.executable, command.args, {
+            cwd: command.cwd,
+            stdio: 'inherit',
+            shell: false,
+        });
+        child.on('error', (error) => {
+            reject(new WorkspaceCliError(`Could not launch ${command.openerLabel}: ${asErrorMessage(error)}`, 'workspace_opener_launch_failed', {
+                target: 'workspace.opener',
+            }));
+        });
+        child.on('close', (code, signal) => {
+            if (code === 0) {
+                resolve();
+                return;
+            }
+            const reason = signal ? `signal ${signal}` : `exit code ${code}`;
+            reject(new WorkspaceCliError(`${command.openerLabel} exited with ${reason}.`, 'workspace_opener_launch_failed', {
+                target: 'workspace.opener',
+            }));
+        });
+    });
+}
+//# sourceMappingURL=open.js.map

package/dist/commands/workspace/operations.d.ts

@@ -0,0 +1,18 @@
+import { WorkspacePreferredOpener, WorkspaceRegistryEntry, WorkspaceRegistryState } from '../../core/workspace/index.js';
+import { SelectedWorkspace, WorkspaceLinkMutationPayload, WorkspaceListOutput, WorkspaceOutput, WorkspaceStatus } from './types.js';
+export declare function readRegistry(): Promise<WorkspaceRegistryState>;
+export declare function directoryExists(dirPath: string): Promise<boolean>;
+export declare function resolveExistingDirectory(inputPath: string, cwd?: string): Promise<string>;
+export declare function inferLinkName(absolutePath: string): string;
+export declare function validateWorkspaceNameForSetup(name: string): string;
+export declare function validateLinkNameForCommand(name: string): string;
+export declare function createManagedWorkspace(name: string, links: Record<string, string>, preferredOpener?: WorkspacePreferredOpener): Promise<WorkspaceOutput>;
+export declare function parseSetupLinks(linkInputs: string[] | undefined): Promise<Record<string, string>>;
+export declare function loadWorkspaceForList(entry: WorkspaceRegistryEntry): Promise<WorkspaceListOutput>;
+export declare function loadWorkspaceForDoctor(selected: SelectedWorkspace): Promise<{
+    workspace: WorkspaceOutput;
+    status: WorkspaceStatus[];
+}>;
+export declare function addWorkspaceLink(selected: SelectedWorkspace, nameOrPath: string, linkPath?: string): Promise<WorkspaceLinkMutationPayload>;
+export declare function updateWorkspaceLink(selected: SelectedWorkspace, linkNameInput: string, linkPath: string): Promise<WorkspaceLinkMutationPayload>;
+//# sourceMappingURL=operations.d.ts.map