praxis-agent 0.35.0 → 0.37.0

package/dist/cli/tui/decision-surface-model.d.ts

@@ -0,0 +1,71 @@
+import type { ClaudePlanApprovalRequest, ClaudeQuestion } from '../../tools/claude-interactive-tools.js';
+import type { ClaudePermissionMode } from '../../permissions/claude-permission-resolver.js';
+export type TuiPlanElevatedMode = Extract<ClaudePermissionMode, 'auto' | 'bypassPermissions' | 'acceptEdits'>;
+export interface TuiDecisionSurfaceAction {
+    readonly visualLabel?: string;
+    readonly screenReaderLabel: string;
+}
+export interface TuiDecisionSurfaceOption {
+    readonly index: number;
+    readonly label: string;
+    readonly description?: string;
+    readonly preview?: string;
+    readonly selected: boolean;
+}
+export interface TuiDecisionSurfaceCancellation {
+    readonly visualLabel: string;
+    readonly screenReaderLabel: string;
+}
+export interface TuiDecisionSurfaceRange {
+    readonly min: number;
+    readonly max: number;
+}
+export type TuiDecisionSurfaceInput = {
+    readonly kind: 'plan-approval';
+    readonly request: ClaudePlanApprovalRequest;
+    readonly selectedIndex: number;
+    readonly feedbackMode: boolean;
+    readonly feedback: string;
+    readonly elevatedMode: TuiPlanElevatedMode;
+} | {
+    readonly kind: 'question';
+    readonly questions: readonly ClaudeQuestion[];
+    readonly questionIndex: number;
+    readonly answer: string;
+};
+export interface TuiPlanApprovalSurfaceModel {
+    readonly kind: 'plan-approval';
+    readonly heading: 'Ready to code?';
+    readonly intro: "Here is Praxis's plan:";
+    readonly explanation: string;
+    readonly planPath: string;
+    readonly plan?: string;
+    readonly options: readonly TuiDecisionSurfaceOption[];
+    readonly selectedIndex: number;
+    readonly range: TuiDecisionSurfaceRange;
+    readonly feedbackMode: boolean;
+    readonly feedback: string;
+    readonly feedbackPlaceholder: string;
+    readonly actions: readonly TuiDecisionSurfaceAction[];
+    readonly cancellation: TuiDecisionSurfaceCancellation;
+}
+export interface TuiQuestionSurfaceModel {
+    readonly kind: 'question';
+    readonly questionIndex: number;
+    readonly questionCount: number;
+    readonly progress: string;
+    readonly header: string;
+    readonly question: string;
+    readonly heading: string;
+    readonly multiSelect: boolean;
+    readonly answer: string;
+    readonly options: readonly TuiDecisionSurfaceOption[];
+    readonly range: TuiDecisionSurfaceRange;
+    readonly guidance?: string;
+    readonly actions: readonly TuiDecisionSurfaceAction[];
+    readonly cancellation: TuiDecisionSurfaceCancellation;
+    readonly emptyState?: string;
+}
+export type TuiDecisionSurfaceModel = TuiPlanApprovalSurfaceModel | TuiQuestionSurfaceModel;
+export declare function projectTuiDecisionSurface(input: TuiDecisionSurfaceInput): TuiDecisionSurfaceModel;
+//# sourceMappingURL=decision-surface-model.d.ts.map

package/dist/cli/tui/decision-surface-model.js

@@ -0,0 +1,131 @@
+function normalizeIndex(value, count, empty = -1) {
+    if (count === 0)
+        return empty;
+    const integer = Number.isFinite(value) ? Math.trunc(value) : 0;
+    return Math.max(0, Math.min(count - 1, integer));
+}
+function range(count) {
+    return { min: count > 0 ? 1 : 0, max: count };
+}
+const cancellation = {
+    visualLabel: 'Esc to cancel',
+    screenReaderLabel: 'Escape to cancel',
+};
+const questionCancellation = {
+    visualLabel: 'Esc cancels',
+    screenReaderLabel: 'Escape cancels',
+};
+function projectedOptions(options, selectedIndex) {
+    return options.map((option, index) => ({
+        index: index + 1,
+        label: option.label,
+        ...(option.description === undefined
+            ? {}
+            : { description: option.description }),
+        ...(option.preview === undefined ? {} : { preview: option.preview }),
+        selected: index === selectedIndex,
+    }));
+}
+function emptyQuestionModel(answer) {
+    return {
+        kind: 'question',
+        questionIndex: -1,
+        questionCount: 0,
+        progress: 'Question 0 of 0',
+        header: '',
+        question: '',
+        heading: 'Question',
+        multiSelect: false,
+        answer,
+        options: [],
+        range: range(0),
+        actions: [],
+        cancellation: questionCancellation,
+        emptyState: 'No questions available.',
+    };
+}
+export function projectTuiDecisionSurface(input) {
+    if (input.kind === 'plan-approval') {
+        const selectedIndex = normalizeIndex(input.selectedIndex, 3);
+        const elevatedLabel = input.elevatedMode === 'auto'
+            ? 'Yes, and use auto mode'
+            : input.elevatedMode === 'bypassPermissions'
+                ? 'Yes, and bypass permissions'
+                : 'Yes, auto-accept edits';
+        const options = projectedOptions([
+            { label: elevatedLabel },
+            { label: 'Yes, manually approve edits' },
+            { label: 'No, keep planning' },
+        ], selectedIndex);
+        return {
+            kind: 'plan-approval',
+            heading: 'Ready to code?',
+            intro: "Here is Praxis's plan:",
+            explanation: 'Praxis has written up a plan and is ready to execute. Would you like to proceed?',
+            planPath: input.request.planPath,
+            ...(input.request.plan ? { plan: input.request.plan } : {}),
+            options,
+            selectedIndex,
+            range: range(options.length),
+            feedbackMode: input.feedbackMode,
+            feedback: input.feedback,
+            feedbackPlaceholder: selectedIndex === 2
+                ? 'Tell Praxis what to change'
+                : 'Add feedback for implementation',
+            actions: input.feedbackMode
+                ? [
+                    {
+                        visualLabel: 'Enter to submit',
+                        screenReaderLabel: 'Enter to submit',
+                    },
+                    {
+                        visualLabel: 'Tab to collapse',
+                        screenReaderLabel: 'Tab to collapse feedback',
+                    },
+                ]
+                : [
+                    {
+                        visualLabel: 'Enter to confirm',
+                        screenReaderLabel: 'Enter selection [1-3]',
+                    },
+                    {
+                        visualLabel: 'Tab to add feedback',
+                        screenReaderLabel: 'Tab to add feedback',
+                    },
+                    { screenReaderLabel: 'Use up/down arrows to change selection' },
+                    { screenReaderLabel: 'Press 1, 2, or 3 to choose directly' },
+                    { screenReaderLabel: 'Press y to approve' },
+                    { screenReaderLabel: 'Press n to keep planning' },
+                ],
+            cancellation,
+        };
+    }
+    const count = input.questions.length;
+    const questionIndex = normalizeIndex(input.questionIndex, count);
+    if (count === 0)
+        return emptyQuestionModel(input.answer);
+    const current = input.questions[questionIndex];
+    if (current === undefined)
+        return emptyQuestionModel(input.answer);
+    const options = projectedOptions(current.options, -1);
+    const guidance = current.multiSelect
+        ? 'Enter comma-separated option numbers or custom text'
+        : 'Enter one option number or custom text';
+    return {
+        kind: 'question',
+        questionIndex,
+        questionCount: count,
+        progress: `Question ${questionIndex + 1} of ${count}`,
+        header: current.header,
+        question: current.question,
+        heading: `${current.header}: ${current.question}`,
+        multiSelect: current.multiSelect,
+        answer: input.answer,
+        options,
+        range: range(options.length),
+        guidance,
+        actions: [{ visualLabel: guidance, screenReaderLabel: guidance }],
+        cancellation: questionCancellation,
+    };
+}
+//# sourceMappingURL=decision-surface-model.js.map

package/dist/cli/tui/decision-surface.d.ts

@@ -0,0 +1,7 @@
+import type { TuiDecisionSurfaceModel } from './decision-surface-model.js';
+export declare function DecisionSurface({ model, width, screenReader, }: {
+    model: TuiDecisionSurfaceModel;
+    width: number;
+    screenReader: boolean;
+}): import("react").JSX.Element;
+//# sourceMappingURL=decision-surface.d.ts.map

package/dist/cli/tui/decision-surface.js

@@ -0,0 +1,41 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Box, Text } from 'ink';
+import { DialogFrame } from './claude-style.js';
+import { useTuiTheme } from './theme.js';
+function Footer({ actions, cancellation, screenReader, }) {
+    const labels = actions.flatMap((action) => screenReader
+        ? [action.screenReaderLabel]
+        : action.visualLabel === undefined
+            ? []
+            : [action.visualLabel]);
+    return (_jsx(Text, { dimColor: true, children: labels
+            .concat(screenReader
+            ? cancellation.screenReaderLabel
+            : cancellation.visualLabel)
+            .join(' · ') }));
+}
+function Option({ option, screenReader, }) {
+    const theme = useTuiTheme();
+    const selected = option.selected;
+    return (_jsxs(Text, { ...(selected ? theme.text.selectedRow : {}), children: [screenReader || theme.noColor
+                ? selected
+                    ? 'Selected: '
+                    : ''
+                : selected
+                    ? '❯ '
+                    : '  ', option.index, ". ", option.label, option.description ? `: ${option.description}` : ''] }));
+}
+function PlanSurface({ model, screenReader, }) {
+    return (_jsxs(DialogFrame, { title: model.heading, screenReader: screenReader, children: [_jsx(Text, { children: model.intro }), model.plan ? (_jsx(Box, { borderStyle: screenReader ? undefined : 'classic', borderLeft: false, borderRight: false, paddingX: screenReader ? 0 : 1, marginY: 1, children: _jsx(Text, { children: model.plan }) })) : null, _jsx(Text, { dimColor: true, children: model.explanation }), model.options.map((option) => (_jsx(Option, { option: option, screenReader: screenReader }, option.index))), model.feedbackMode ? (_jsxs(Text, { children: [screenReader ? 'Feedback: ' : '› ', model.feedback || model.feedbackPlaceholder] })) : null, _jsx(Text, { dimColor: true, children: model.planPath }), _jsx(Footer, { ...model, screenReader: screenReader })] }));
+}
+function QuestionSurface({ model, screenReader, }) {
+    return (_jsxs(DialogFrame, { title: model.heading, screenReader: screenReader, children: [_jsx(Text, { children: model.progress }), model.emptyState ? _jsx(Text, { dimColor: true, children: model.emptyState }) : null, model.options.map((option) => (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { children: [option.index, ". ", option.label, option.description ? ` — ${option.description}` : ''] }), option.preview ? _jsx(Text, { dimColor: true, children: option.preview }) : null] }, `${option.index}-${option.label}`))), _jsxs(Text, { children: [screenReader ? 'Current answer: ' : '› ', model.answer || (screenReader ? '(empty)' : '')] }), _jsx(Footer, { ...model, screenReader: screenReader })] }));
+}
+export function DecisionSurface({ model, width, screenReader, }) {
+    const content = model.kind === 'plan-approval' ? (_jsx(PlanSurface, { model: model, screenReader: screenReader })) : (_jsx(QuestionSurface, { model: model, screenReader: screenReader }));
+    const normalizedWidth = Number.isFinite(width)
+        ? Math.min(100, Math.max(1, Math.trunc(width)))
+        : 100;
+    return screenReader ? content : _jsx(Box, { width: normalizedWidth, children: content });
+}
+//# sourceMappingURL=decision-surface.js.map

package/dist/cli/tui/help-surface-model.d.ts

@@ -0,0 +1,68 @@
+export type TuiHelpTabId = 'general' | 'commands' | 'custom-commands';
+export interface TuiHelpShortcut {
+    readonly id: string;
+    readonly key: string;
+    readonly description: string;
+}
+export interface TuiHelpShortcutGroup {
+    readonly id: string;
+    readonly shortcuts: readonly TuiHelpShortcut[];
+}
+export interface TuiHelpCommandInput {
+    readonly name: string;
+    readonly description: string;
+}
+export interface TuiHelpCommandRow {
+    readonly id: string;
+    readonly ordinal: number;
+    readonly invocation: string;
+    readonly description: string;
+}
+export interface TuiHelpDocumentation {
+    readonly label: 'Praxis documentation';
+    readonly url: 'https://github.com/Forest-Isle/Praxis';
+}
+export interface TuiHelpGeneralContent {
+    readonly kind: 'general';
+    readonly description: string;
+    readonly shortcutGroups: readonly TuiHelpShortcutGroup[];
+}
+export interface TuiHelpCommandContent {
+    readonly kind: 'commands' | 'custom-commands';
+    readonly heading: string;
+    readonly commands: readonly TuiHelpCommandRow[];
+    readonly focusedIndex: number | null;
+    readonly emptyText: string;
+}
+export type TuiHelpActiveContent = TuiHelpGeneralContent | TuiHelpCommandContent;
+export interface TuiHelpTab {
+    readonly id: TuiHelpTabId;
+    readonly label: 'General' | 'Commands' | 'Custom commands';
+    readonly current: boolean;
+}
+export interface TuiHelpSurfaceInput {
+    readonly invocation: '?' | '/help';
+    readonly tabIndex: number;
+    readonly selectedIndex: number;
+    readonly builtinCommands: readonly TuiHelpCommandInput[];
+    readonly customCommands: readonly TuiHelpCommandInput[];
+}
+export interface TuiHelpSurfaceModel {
+    readonly kind: 'help';
+    readonly title: 'Help';
+    readonly invocation: '?' | '/help';
+    readonly tabs: readonly TuiHelpTab[];
+    readonly activeTab: {
+        readonly id: TuiHelpTabId;
+        readonly label: TuiHelpTab['label'];
+    };
+    readonly activeContent: TuiHelpActiveContent;
+    readonly navigation: {
+        readonly switchTabs: 'Left/Right to switch tabs';
+        readonly browseCommands?: 'Up/Down to browse commands';
+        readonly close: 'Esc to close';
+    };
+    readonly documentation: TuiHelpDocumentation;
+}
+export declare function projectTuiHelpSurface(input: TuiHelpSurfaceInput): TuiHelpSurfaceModel;
+//# sourceMappingURL=help-surface-model.d.ts.map

package/dist/cli/tui/help-surface-model.js

@@ -0,0 +1,131 @@
+const TAB_DEFINITIONS = [
+    { id: 'general', label: 'General' },
+    { id: 'commands', label: 'Commands' },
+    { id: 'custom-commands', label: 'Custom commands' },
+];
+const SHORTCUT_GROUPS = [
+    {
+        id: 'prompt',
+        shortcuts: [
+            { id: 'bash-mode', key: '!', description: 'for bash mode' },
+            { id: 'commands', key: '/', description: 'for commands' },
+            { id: 'file-paths', key: '@', description: 'for file paths' },
+            { id: 'background', key: '&', description: 'for background' },
+            { id: 'side-question', key: '/btw', description: 'for side question' },
+        ],
+    },
+    {
+        id: 'navigation',
+        shortcuts: [
+            {
+                id: 'clear-input',
+                key: 'double tap esc',
+                description: 'to clear input',
+            },
+            {
+                id: 'auto-accept-edits',
+                key: 'shift + tab',
+                description: 'to auto-accept edits',
+            },
+            {
+                id: 'verbose-output',
+                key: 'ctrl + o',
+                description: 'for verbose output',
+            },
+            { id: 'toggle-tasks', key: 'ctrl + t', description: 'to toggle tasks' },
+            {
+                id: 'newline',
+                key: 'backslash (\\) + return (⏎)',
+                description: 'for newline',
+            },
+        ],
+    },
+    {
+        id: 'editing',
+        shortcuts: [
+            { id: 'undo', key: 'ctrl + shift + _', description: 'to undo' },
+            { id: 'suspend', key: 'ctrl + z', description: 'to suspend' },
+            { id: 'paste-images', key: 'ctrl + v', description: 'to paste images' },
+            { id: 'switch-model', key: 'opt + p', description: 'to switch model' },
+            { id: 'stash-prompt', key: 'ctrl + s', description: 'to stash prompt' },
+            {
+                id: 'external-editor',
+                key: 'ctrl + g',
+                description: 'to edit in $EDITOR',
+            },
+            {
+                id: 'customize-keybindings',
+                key: '/keybindings',
+                description: 'to customize',
+            },
+        ],
+    },
+];
+const DOCUMENTATION = {
+    label: 'Praxis documentation',
+    url: 'https://github.com/Forest-Isle/Praxis',
+};
+const GENERAL_DESCRIPTION = 'Praxis understands your codebase, makes edits with your permission, and executes commands from your terminal.';
+function normalizeIndex(value) {
+    return Number.isFinite(value) ? Math.trunc(value) : 0;
+}
+function clamp(value, minimum, maximum) {
+    const normalized = normalizeIndex(value);
+    return Math.max(minimum, Math.min(maximum, normalized));
+}
+function projectCommands(commands, tab, selectedIndex) {
+    const rows = commands.map((command, index) => ({
+        id: `${tab}:${index}:${command.name}`,
+        ordinal: index + 1,
+        invocation: `/${command.name}`,
+        description: command.description,
+    }));
+    return {
+        kind: tab,
+        heading: tab === 'commands'
+            ? 'Browse default commands'
+            : 'Browse shared commands and skills',
+        commands: rows,
+        focusedIndex: rows.length === 0 ? null : clamp(selectedIndex, 0, rows.length - 1),
+        emptyText: 'No commands found.',
+    };
+}
+export function projectTuiHelpSurface(input) {
+    const tabIndex = clamp(input.tabIndex, 0, TAB_DEFINITIONS.length - 1);
+    const activeTab = tabIndex === 0
+        ? TAB_DEFINITIONS[0]
+        : tabIndex === 1
+            ? TAB_DEFINITIONS[1]
+            : TAB_DEFINITIONS[2];
+    const tabs = TAB_DEFINITIONS.map((tab) => ({
+        ...tab,
+        current: tab.id === activeTab.id,
+    }));
+    const activeContent = activeTab.id === 'general'
+        ? {
+            kind: 'general',
+            description: GENERAL_DESCRIPTION,
+            shortcutGroups: SHORTCUT_GROUPS,
+        }
+        : projectCommands(activeTab.id === 'commands'
+            ? input.builtinCommands
+            : input.customCommands, activeTab.id, input.selectedIndex);
+    return {
+        kind: 'help',
+        title: 'Help',
+        invocation: input.invocation,
+        tabs,
+        activeTab,
+        activeContent,
+        navigation: {
+            switchTabs: 'Left/Right to switch tabs',
+            ...(activeContent.kind === 'general' ||
+                activeContent.commands.length === 0
+                ? {}
+                : { browseCommands: 'Up/Down to browse commands' }),
+            close: 'Esc to close',
+        },
+        documentation: DOCUMENTATION,
+    };
+}
+//# sourceMappingURL=help-surface-model.js.map

package/dist/cli/tui/mcp-panel.js

@@ -1,6 +1,5 @@
 import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
 import { Box, Text } from 'ink';
-import { useTerminalWidth } from './claude-style.js';
 import { tuiMcpServerActions, } from './mcp-panel-projector.js';
 const CLAUDE_EMPTY_MESSAGE = 'No MCP servers configured. Run claude doctor if this is unexpected — it lists MCP config files that failed validation. Otherwise, run claude mcp --help or visit https://code.claude.com/docs/en/mcp to learn more.';
 const SCOPE_LABELS = {
@@ -75,7 +74,7 @@ function ToolPanel({ server, state, }) {
     return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { bold: true, children: tool.name }), _jsx(Text, { children: server.name }), _jsxs(Text, { children: ["Tool name: ", ' ' + tool.name] }), _jsxs(Text, { children: ["Full name: ", ' ' + tool.fullName] }), _jsx(Text, { children: "Description:" }), _jsx(Text, { children: tool.description ?? '' }), _jsx(Text, { dimColor: true, children: "Esc to go back" })] }));
 }
 export function McpPanel({ model, state, screenReader = false, width, dataPlane = 'claude', }) {
-    const terminalWidth = useTerminalWidth(width);
+    const terminalWidth = width ?? 80;
     const server = model.servers[state.serverIndex];
     let content;
     if (model.servers.length === 0)

package/dist/cli/tui/permission-surface-model.d.ts

@@ -0,0 +1,195 @@
+import type { ComposerEditorState } from './composer-editor.js';
+import type { TuiPermissionBehavior, TuiPermissionRule } from './permission-settings.js';
+import type { RecentlyDeniedAction } from './recently-denied.js';
+import type { TuiToolPermissionModel, TuiToolPermissionOption } from './tool-permission.js';
+export type TuiPermissionSurfaceInput = {
+    kind: 'tool-request';
+    model: TuiToolPermissionModel;
+    selection: number;
+    feedbackMode: boolean;
+    feedback: string;
+    ruleEditor?: ComposerEditorState | null;
+} | {
+    kind: 'recovery-request';
+    display: string;
+    heading?: string;
+    selection: number;
+    feedbackMode: boolean;
+    feedback: string;
+} | {
+    kind: 'permission-dashboard';
+    tabIndex: number;
+    selectedIndex: number;
+    query: string;
+    rules: readonly TuiPermissionRule[];
+    recentDenied: readonly RecentlyDeniedAction[];
+    retryingDeniedId?: string | null;
+    workspaceDirectories: readonly {
+        path: string;
+        original: boolean;
+    }[];
+} | {
+    kind: 'permission-rule-input';
+    behavior: TuiPermissionBehavior;
+    value: string;
+} | {
+    kind: 'permission-scope';
+    behavior: TuiPermissionBehavior;
+    rule: string;
+    selectedIndex: number;
+    settingsDirectory: string;
+} | {
+    kind: 'permission-delete';
+    rule: TuiPermissionRule;
+    selectedIndex: number;
+} | {
+    kind: 'workspace-directory-input';
+    value: string;
+} | {
+    kind: 'workspace-directory-delete';
+    path: string;
+    selectedIndex: number;
+};
+export interface TuiPermissionSurfaceAction {
+    readonly label: string;
+    readonly key?: string;
+    readonly screenReaderLabel?: string;
+    readonly usesSelectionRange?: boolean;
+}
+export interface TuiPermissionSurfaceOption {
+    readonly index: number;
+    readonly label: string;
+    readonly description?: string;
+    readonly selected: boolean;
+    readonly value?: string;
+}
+export interface TuiPermissionSurfaceRow {
+    readonly index: number;
+    readonly label: string;
+    readonly description?: string;
+    readonly selected: boolean;
+    readonly id?: string;
+    readonly status?: 'denied' | 'retrying';
+    readonly original?: boolean;
+}
+export interface TuiPermissionDashboardModel {
+    readonly kind: 'permission-dashboard';
+    readonly heading: 'Permissions';
+    readonly tabs: readonly {
+        readonly index: number;
+        readonly label: string;
+        readonly current: boolean;
+    }[];
+    readonly tabIndex: number;
+    readonly description: string;
+    readonly query: string;
+    readonly rows: readonly TuiPermissionSurfaceRow[];
+    readonly emptyState?: string;
+    readonly originalWorkspace?: TuiPermissionSurfaceRow;
+    readonly range: {
+        readonly min: number;
+        readonly max: number;
+    };
+    readonly actions: readonly TuiPermissionSurfaceAction[];
+    readonly cancellation: string;
+}
+export interface TuiPermissionToolRequestModel {
+    readonly kind: 'tool-request';
+    readonly heading: string;
+    readonly tool: TuiToolPermissionModel;
+    readonly options: readonly TuiToolPermissionOption[];
+    readonly selectedIndex: number;
+    readonly range: {
+        readonly min: number;
+        readonly max: number;
+    };
+    readonly feedbackMode: boolean;
+    readonly feedback: string;
+    readonly ruleEditor?: ComposerEditorState | null;
+    readonly actions: readonly TuiPermissionSurfaceAction[];
+    readonly cancellation: string;
+}
+export interface TuiPermissionRecoveryRequestModel {
+    readonly kind: 'recovery-request';
+    readonly heading: string;
+    readonly display: string;
+    readonly question: string;
+    readonly options: readonly TuiPermissionSurfaceOption[];
+    readonly selectedIndex: number;
+    readonly range: {
+        readonly min: number;
+        readonly max: number;
+    };
+    readonly feedbackMode: boolean;
+    readonly feedback: string;
+    readonly feedbackPlaceholder: string;
+    readonly actions: readonly TuiPermissionSurfaceAction[];
+    readonly cancellation: string;
+}
+export interface TuiPermissionRuleInputModel {
+    readonly kind: 'permission-rule-input';
+    readonly heading: string;
+    readonly behavior: TuiPermissionBehavior;
+    readonly value: string;
+    readonly description: string;
+    readonly placeholder: string;
+    readonly actions: readonly TuiPermissionSurfaceAction[];
+    readonly cancellation: string;
+}
+export interface TuiPermissionScopeModel {
+    readonly kind: 'permission-scope';
+    readonly heading: string;
+    readonly behavior: TuiPermissionBehavior;
+    readonly rule: string;
+    readonly description: string;
+    readonly options: readonly TuiPermissionSurfaceOption[];
+    readonly selectedIndex: number;
+    readonly range: {
+        readonly min: number;
+        readonly max: number;
+    };
+    readonly actions: readonly TuiPermissionSurfaceAction[];
+    readonly cancellation: string;
+}
+export interface TuiPermissionDeleteModel {
+    readonly kind: 'permission-delete';
+    readonly heading: string;
+    readonly rule: string;
+    readonly description?: string;
+    readonly scope: string;
+    readonly question: string;
+    readonly options: readonly TuiPermissionSurfaceOption[];
+    readonly selectedIndex: number;
+    readonly range: {
+        readonly min: number;
+        readonly max: number;
+    };
+    readonly actions: readonly TuiPermissionSurfaceAction[];
+    readonly cancellation: string;
+}
+export interface TuiWorkspaceDirectoryInputModel {
+    readonly kind: 'workspace-directory-input';
+    readonly heading: string;
+    readonly description: string;
+    readonly value: string;
+    readonly placeholder: string;
+    readonly actions: readonly TuiPermissionSurfaceAction[];
+    readonly cancellation: string;
+}
+export interface TuiWorkspaceDirectoryDeleteModel {
+    readonly kind: 'workspace-directory-delete';
+    readonly heading: string;
+    readonly path: string;
+    readonly description: string;
+    readonly options: readonly TuiPermissionSurfaceOption[];
+    readonly selectedIndex: number;
+    readonly range: {
+        readonly min: number;
+        readonly max: number;
+    };
+    readonly actions: readonly TuiPermissionSurfaceAction[];
+    readonly cancellation: string;
+}
+export type TuiPermissionSurfaceModel = TuiPermissionToolRequestModel | TuiPermissionRecoveryRequestModel | TuiPermissionDashboardModel | TuiPermissionRuleInputModel | TuiPermissionScopeModel | TuiPermissionDeleteModel | TuiWorkspaceDirectoryInputModel | TuiWorkspaceDirectoryDeleteModel;
+export declare function projectTuiPermissionSurface(input: TuiPermissionSurfaceInput): TuiPermissionSurfaceModel;
+//# sourceMappingURL=permission-surface-model.d.ts.map