langflower 0.1.0 → 0.1.2

package/vendor/common-nodes/dist/ai/llm-role-preset.js

@@ -1,265 +0,0 @@
-/** Instance role preset — one LLM node type, many configured roles. */
-export const LLM_ROLE_PRESET_OPTIONS = [
-    { value: 'custom', title: 'Custom' },
-    { value: 'plan', title: 'Plan' },
-    { value: 'coder', title: 'Coder' },
-    { value: 'explorer', title: 'Explorer' },
-];
-/**
- * Harness builtin ids — twin of `@langflower/tools` `BUILTIN_TOOL_IDS` and
- * shared `HARNESS_BUILTIN_TOOL_OPTIONS`. Kept local so UI can import this
- * module without bundling Node builtins from tools.
- */
-export const HARNESS_BUILTIN_TOOL_IDS = [
-    'read',
-    'glob',
-    'grep',
-    'edit',
-    'write',
-    'create',
-    'delete',
-    'bash',
-];
-export const PLAN_AGENT_SYSTEM_PROMPT = [
-    'You are the Plan agent in a Langflower workflow.',
-    '',
-    "Understand the user's goal, explore the codebase read-only, and produce a clear",
-    'implementation plan. Do not modify source code or non-documentation files.',
-    '',
-    'Write plans in Markdown with sections: Goal, Context, Steps, Risks, Open questions.',
-    '',
-    'When requirements are ambiguous, use ask_user before finalizing the plan.',
-].join('\n');
-export const CODER_AGENT_SYSTEM_PROMPT = [
-    'You are the Coder agent in a Langflower workflow.',
-    '',
-    'Implement the requested changes in the project repository. Make minimal, correct',
-    'edits. Prefer precise file edits over large rewrites.',
-    '',
-    'When tests are available, run them to verify your work. Summarize what you changed',
-    'in your final response.',
-].join('\n');
-const EXPLORER_AGENT_SYSTEM_PROMPT = [
-    'You are the Explorer agent in a Langflower workflow.',
-    '',
-    'Research the topic using web_fetch. Synthesize findings into clear Markdown notes.',
-    'Do not modify application source code—only *.md research notes.',
-    '',
-    'Cite URLs. Separate facts from inference.',
-].join('\n');
-const allAllow = () => Object.fromEntries(HARNESS_BUILTIN_TOOL_IDS.map((id) => [id, 'allow']));
-const CUSTOM_TOOL_PERMISSIONS = allAllow();
-const CODER_TOOL_PERMISSIONS = {
-    ...allAllow(),
-    bash: 'ask',
-    delete: 'ask',
-};
-const PLAN_TOOL_PERMISSIONS = {
-    ...allAllow(),
-    write: 'ask',
-    create: 'ask',
-    edit: 'deny',
-    delete: 'deny',
-    bash: 'deny',
-};
-const EXPLORER_TOOL_PERMISSIONS = {
-    ...allAllow(),
-    read: 'allow',
-    write: 'ask',
-    create: 'ask',
-    glob: 'deny',
-    grep: 'deny',
-    edit: 'deny',
-    delete: 'deny',
-    bash: 'deny',
-};
-export const LLM_ROLE_PRESET_DEFAULTS = {
-    custom: {
-        systemPrompt: '',
-        skillId: '',
-        toolPermissions: CUSTOM_TOOL_PERMISSIONS,
-    },
-    plan: {
-        systemPrompt: PLAN_AGENT_SYSTEM_PROMPT,
-        skillId: 'plan',
-        toolPermissions: PLAN_TOOL_PERMISSIONS,
-    },
-    coder: {
-        systemPrompt: CODER_AGENT_SYSTEM_PROMPT,
-        skillId: 'coder',
-        toolPermissions: CODER_TOOL_PERMISSIONS,
-    },
-    explorer: {
-        systemPrompt: EXPLORER_AGENT_SYSTEM_PROMPT,
-        skillId: 'explorer',
-        toolPermissions: EXPLORER_TOOL_PERMISSIONS,
-    },
-};
-export const parseLlmRolePreset = (value) => {
-    if (value === 'plan' || value === 'coder' || value === 'explorer') {
-        return value;
-    }
-    return 'custom';
-};
-export const resolveEffectiveSkillId = (rolePreset, skillIdParam) => {
-    const explicit = typeof skillIdParam === 'string' ? skillIdParam.trim() : '';
-    if (explicit !== '') {
-        return explicit;
-    }
-    return LLM_ROLE_PRESET_DEFAULTS[rolePreset].skillId;
-};
-const isToolPermissionDecision = (value) => value === 'allow' || value === 'ask' || value === 'deny';
-/** Parse `params.toolPermissions` into a validated map (empty if unset). */
-export const parseToolPermissions = (value) => {
-    if (value === null || typeof value !== 'object' || Array.isArray(value)) {
-        return {};
-    }
-    const entries = Object.entries(value).filter((entry) => isToolPermissionDecision(entry[1]));
-    return Object.fromEntries(entries);
-};
-/**
- * Migrate legacy `enabledToolIds` allowlist → coarse toolPermissions.
- * Listed → allow (bash/delete → ask); unlisted builtins → deny.
- */
-export const migrateEnabledToolIdsToPermissions = (enabledToolIds) => {
-    const allowed = new Set(enabledToolIds);
-    const next = {};
-    for (const id of HARNESS_BUILTIN_TOOL_IDS) {
-        if (!allowed.has(id)) {
-            next[id] = 'deny';
-            continue;
-        }
-        next[id] = id === 'bash' || id === 'delete' ? 'ask' : 'allow';
-    }
-    for (const id of enabledToolIds) {
-        if (!(id in next)) {
-            next[id] = 'allow';
-        }
-    }
-    return next;
-};
-/**
- * Resolve node toolPermissions: explicit map, else migrate enabledToolIds,
- * else preset defaults for the current role.
- */
-export const resolveEffectiveToolPermissions = (rolePreset, toolPermissionsParam, enabledToolIdsParam) => {
-    const parsed = parseToolPermissions(toolPermissionsParam);
-    if (Object.keys(parsed).length > 0) {
-        return parsed;
-    }
-    if (Array.isArray(enabledToolIdsParam)) {
-        return migrateEnabledToolIdsToPermissions(enabledToolIdsParam.map(String));
-    }
-    return LLM_ROLE_PRESET_DEFAULTS[rolePreset].toolPermissions;
-};
-/** Inventory ids whose decision is not deny. */
-export const toolPermissionsToEnabledIds = (toolPermissions) => Object.entries(toolPermissions)
-    .filter(([, decision]) => decision !== 'deny')
-    .map(([toolId]) => toolId);
-/**
- * Params patch when the author selects a role preset in the Inspector.
- *
- * - Writes `rolePreset` + materializes `toolPermissions`.
- * - Removes legacy `enabledToolIds`.
- * - Does **not** touch `skillId` / `systemPrompt`.
- */
-export const paramsAfterRolePresetApply = (currentParams, rolePreset) => {
-    const { enabledToolIds: _legacy, toolPermissions: _previous, ...rest } = currentParams;
-    const defaults = LLM_ROLE_PRESET_DEFAULTS[rolePreset];
-    return {
-        ...rest,
-        rolePreset,
-        toolPermissions: { ...defaults.toolPermissions },
-    };
-};
-/** Defaults twin of `@langflower/tools` `DEFAULT_PERMISSION_CONFIG` (allow-all). */
-const DEFAULT_HARNESS_PERMISSION = {
-    read: { '*': 'allow' },
-    glob: { '*': 'allow' },
-    grep: { '*': 'allow' },
-    edit: { '*': 'allow' },
-    write: { '*': 'allow' },
-    create: { '*': 'allow' },
-    delete: { '*': 'allow' },
-    bash: { '*': 'allow' },
-};
-const DECISION_RANK = {
-    deny: 3,
-    ask: 2,
-    allow: 1,
-};
-const rulesForTool = (config, toolId) => {
-    const raw = config[toolId] ?? DEFAULT_HARNESS_PERMISSION[toolId];
-    if (raw === undefined) {
-        return { '*': 'allow' };
-    }
-    if (isToolPermissionDecision(raw)) {
-        return { '*': raw };
-    }
-    const entries = Object.entries(raw).filter((entry) => isToolPermissionDecision(entry[1]));
-    if (entries.length === 0) {
-        return { '*': 'deny' };
-    }
-    return Object.fromEntries(entries);
-};
-/** Coarse floor for Inspector (parity with tools `toolFloorDecision`). */
-export const toolFloorDecisionForUi = (config, toolId) => {
-    const merged = {
-        ...DEFAULT_HARNESS_PERMISSION,
-        ...(config ?? {}),
-    };
-    if (merged[toolId] === undefined &&
-        DEFAULT_HARNESS_PERMISSION[toolId] === undefined) {
-        return 'allow';
-    }
-    const rules = rulesForTool(merged, toolId);
-    const star = rules['*'];
-    if (star !== undefined && Object.keys(rules).length === 1) {
-        return star;
-    }
-    const decisions = Object.values(rules);
-    if (decisions.some((decision) => decision === 'allow')) {
-        return 'allow';
-    }
-    if (decisions.some((decision) => decision === 'ask')) {
-        return 'ask';
-    }
-    return 'deny';
-};
-export const validNodePermissionOptionsForUi = (floor) => {
-    if (floor === 'deny') {
-        return [];
-    }
-    if (floor === 'ask') {
-        return ['deny', 'ask'];
-    }
-    return ['deny', 'ask', 'allow'];
-};
-export const clampToolPermissionForUi = (floor, node) => DECISION_RANK[floor] >= DECISION_RANK[node] ? floor : node;
-export const isHarnessToolAlwaysDenied = (config, toolId) => {
-    const merged = {
-        ...DEFAULT_HARNESS_PERMISSION,
-        ...(config ?? {}),
-    };
-    if (merged[toolId] === undefined &&
-        DEFAULT_HARNESS_PERMISSION[toolId] === undefined) {
-        return false;
-    }
-    const decisions = Object.values(rulesForTool(merged, toolId));
-    return (decisions.length > 0 &&
-        decisions.every((decision) => decision === 'deny'));
-};
-/** Opt-in: newly wired tool ids default to allow when missing. */
-export const mergeToolPermissionsOnNewWires = (toolPermissions, wiredToolIds) => {
-    const next = {
-        ...toolPermissions,
-    };
-    let changed = false;
-    for (const id of wiredToolIds) {
-        if (next[id] === undefined) {
-            next[id] = 'allow';
-            changed = true;
-        }
-    }
-    return changed ? next : toolPermissions;
-};

package/vendor/common-nodes/dist/ai/llm-session/run-session-machine.d.ts

@@ -1,21 +0,0 @@
-import type { ChatCompletionMessage } from '../chat-completion-stream.js';
-import type { PermissionAskRequest } from '@langflower/tools/permission';
-import { type Observable } from 'rxjs';
-export type LlmSessionPreparation<Session> = {
-    readonly history: readonly ChatCompletionMessage[];
-    readonly trackAssistantHistory: boolean;
-    readonly appendUserFeedbackToHistory: boolean;
-    readonly session: Session;
-};
-type LlmSessionContext = {
-    readonly maxFeedbackTurns: number;
-    readonly requestPermission?: (request: PermissionAskRequest) => Promise<'allow' | 'deny'>;
-};
-/**
- * Sequential session fold. Each turn is an inner Observable reduced into the
- * accumulator; concurrency 1 queues feedback while a turn is streaming.
- */
-export declare const runLlmSessionMachine: <Context extends LlmSessionContext, Session, Chunk extends {
-    readonly kind: string;
-}>(context: Context, turn$: Observable<unknown>, preparation: LlmSessionPreparation<Session>, runTurn: (context: Context, turnPayload: unknown, history: readonly ChatCompletionMessage[], session: Session) => Observable<Chunk>, primeTurn0: boolean) => Observable<Chunk>;
-export {};

package/vendor/common-nodes/dist/ai/llm-session/run-session-machine.js

@@ -1,118 +0,0 @@
-import { EMPTY, concat, filter, from, map, mergeScan, of, scan, startWith, switchMap, throwError, } from 'rxjs';
-const isBlankTurn = (raw) => raw === null ||
-    raw === undefined ||
-    (typeof raw === 'string' && raw.trim().length === 0);
-const readHistorySync = (chunk) => {
-    if (chunk.kind !== 'historySync' ||
-        !('messages' in chunk) ||
-        !Array.isArray(chunk.messages)) {
-        return undefined;
-    }
-    return chunk.messages;
-};
-const readAssistantResponse = (chunk) => chunk.kind === 'response' &&
-    'text' in chunk &&
-    typeof chunk.text === 'string'
-    ? chunk.text
-    : undefined;
-const reduceChunk = (state, chunk) => {
-    const syncedHistory = readHistorySync(chunk);
-    if (syncedHistory !== undefined) {
-        return {
-            ...state,
-            history: [...syncedHistory],
-            emitted: chunk,
-        };
-    }
-    const assistantResponse = readAssistantResponse(chunk);
-    if (assistantResponse !== undefined &&
-        state.preparation.trackAssistantHistory) {
-        return {
-            ...state,
-            history: [
-                ...state.history,
-                { role: 'assistant', content: assistantResponse },
-            ],
-            emitted: chunk,
-        };
-    }
-    return { ...state, emitted: chunk };
-};
-const acceptFeedbackTurn = (context, state, raw, runTurn, feedbackTurns) => {
-    const history = state.preparation.appendUserFeedbackToHistory
-        ? [
-            ...state.history,
-            { role: 'user', content: String(raw ?? '') },
-        ]
-        : state.history;
-    const next = {
-        ...state,
-        history,
-        feedbackTurns,
-        emitted: undefined,
-    };
-    return runTurn(context, raw, next.history, next.preparation.session).pipe(scan((accumulator, chunk) => reduceChunk(accumulator, chunk), next));
-};
-const denyMaxFeedbackTurns = (state, maxFeedbackTurns) => {
-    const message = `Stopped: maxFeedbackTurns ` + `(${maxFeedbackTurns}) reached`;
-    return concat(of({
-        ...state,
-        emitted: {
-            kind: 'toolLog',
-            text: `⚠ ${message}`,
-        },
-    }), throwError(() => message));
-};
-const runTurnFromState = (context, state, raw, primeTurn0, runTurn) => {
-    if (!state.turn0Done) {
-        if (!primeTurn0 && isBlankTurn(raw)) {
-            return EMPTY;
-        }
-        const next = { ...state, turn0Done: true };
-        return runTurn(context, primeTurn0 ? undefined : raw, next.history, next.preparation.session).pipe(scan((accumulator, chunk) => reduceChunk(accumulator, chunk), next));
-    }
-    if (isBlankTurn(raw)) {
-        return EMPTY;
-    }
-    if (context.maxFeedbackTurns > 0 &&
-        state.feedbackTurns >= context.maxFeedbackTurns) {
-        const ask = context.requestPermission;
-        if (ask === undefined) {
-            return denyMaxFeedbackTurns(state, context.maxFeedbackTurns);
-        }
-        const waitingText = `⚠ Max feedback turns (${context.maxFeedbackTurns}) reached. ` +
-            'Allow to continue for another budget, or Deny to stop.';
-        return concat(of({
-            ...state,
-            emitted: {
-                kind: 'toolLog',
-                text: waitingText,
-            },
-        }), from(ask({
-            toolId: 'agent.maxFeedbackTurns',
-            detail: String(context.maxFeedbackTurns),
-            summary: `Max feedback turns (${context.maxFeedbackTurns}) ` +
-                'reached. Allow to continue?',
-        })).pipe(switchMap((decision) => {
-            if (decision !== 'allow') {
-                return denyMaxFeedbackTurns(state, context.maxFeedbackTurns);
-            }
-            return acceptFeedbackTurn(context, state, raw, runTurn, 1);
-        })));
-    }
-    return acceptFeedbackTurn(context, state, raw, runTurn, state.feedbackTurns + 1);
-};
-/**
- * Sequential session fold. Each turn is an inner Observable reduced into the
- * accumulator; concurrency 1 queues feedback while a turn is streaming.
- */
-export const runLlmSessionMachine = (context, turn$, preparation, runTurn, primeTurn0) => {
-    const initial = {
-        history: [...preparation.history],
-        turn0Done: false,
-        feedbackTurns: 0,
-        preparation,
-    };
-    const turns$ = primeTurn0 ? turn$.pipe(startWith('')) : turn$;
-    return turns$.pipe(mergeScan((state, raw) => runTurnFromState(context, state, raw, primeTurn0, runTurn), initial, 1), filter((state) => state.emitted !== undefined), map((state) => state.emitted));
-};

package/vendor/common-nodes/dist/ai/llm-session-shell.d.ts

@@ -1,147 +0,0 @@
-import type { ToolHandle, configureOutput, makeInput } from '@langflower/node-sdk';
-import type { ToolHandlerContext } from '@langflower/tools/domain-tool-configs';
-import type { PermissionAskRequest } from '@langflower/tools/permission';
-import type { ChatCompletionMessage } from './chat-completion-stream.js';
-import { type LlmInventoryInputs, type LlmRecoveryNotice, type SteerControlPayload } from '@langflower/node-sdk/llm';
-import type { PortMeta } from '@langflower/node-sdk';
-import type { combineStatefulObservables, StatefulObservable } from '@rx-evo/stateful-observable';
-import { type Observable, type OperatorFunction } from 'rxjs';
-import { type LlmRolePreset } from './llm-role-preset.js';
-import { type SubAgentRegistration, type SubAgentSpawnPayload } from './sub-agent-protocol.js';
-import type { LlmCompactionConfig } from './openai/normalize-compaction-params.js';
-import type { LlmRecoveryPolicy } from './llm-loop/llm-loop-types.js';
-/** Shared inventory + panel fields assembled for OpenAI / Fake agent binds. */
-export type LlmAgentInventoryContext = {
-    readonly prompt: string;
-    readonly tools: readonly ToolHandle[];
-    readonly subagentRegistrations: readonly SubAgentRegistration[];
-    readonly providerId: string;
-    readonly model: string;
-    readonly skillId: string;
-    readonly rolePreset: LlmRolePreset;
-    readonly effectiveSystemPrompt: string;
-    readonly skillMarkdown: string;
-    readonly agentsMarkdown: string;
-    readonly toolCtx: ToolHandlerContext;
-    readonly maxIterations: number;
-    /** Cap on feedback turns after turn 0; 0 = unlimited (Soft↔Hard guardrail). */
-    readonly maxFeedbackTurns: number;
-    /**
-     * HITL continue asks for storm caps (`agent.maxIterations` /
-     * `agent.maxFeedbackTurns`). Missing → Deny (prior stop behavior).
-     */
-    readonly requestPermission?: (request: PermissionAskRequest) => Promise<'allow' | 'deny'>;
-    readonly compaction: LlmCompactionConfig;
-    readonly recovery: LlmRecoveryPolicy;
-    /** ADR-032 soft Pause / Steer — set in {@link bindLlmAgentSession}. */
-    readonly steerControl$?: Observable<SteerControlPayload>;
-};
-/**
- * Prep for the shared LLM session cycle (ADR-016). All LLM nodes MUST use
- * {@link createLlmSessionCycle$} — per-node cold-start history is forbidden.
- */
-export type LlmFeedbackSessionPrep<Session = undefined> = {
-    readonly history: readonly ChatCompletionMessage[];
-    /** Append `{ role: assistant, content }` when a `response` chunk arrives. */
-    readonly trackAssistantHistory: boolean;
-    /** Append turn payload as `{ role: user }` before feedback turns (>0). */
-    readonly appendUserFeedbackToHistory: boolean;
-    readonly session: Session;
-};
-export type LlmSessionCycleOptions = {
-    /**
-     * When true (default, Soft↔Hard / openai-llm), prime turn 0 with
-     * `startWith('')` and call `runTurn` with `turnPayload === undefined`.
-     * When false (Critique `packet` / Review `result`), the first non-empty
-     * turn$ value is turn 0's payload — no empty prime.
-     */
-    readonly primeTurn0?: boolean;
-};
-/** Standard agent cycle chunk kinds demuxed to OpenAI / Fake ports. */
-type StandardLlmAgentChunk = {
-    readonly kind: 'reasoning';
-    readonly text: string;
-} | {
-    readonly kind: 'draftResponse';
-    readonly text: string;
-} | {
-    readonly kind: 'toolLog';
-    readonly text: string;
-} | ({
-    readonly kind: 'recoveryNotice';
-} & LlmRecoveryNotice) | {
-    readonly kind: 'response';
-    readonly text: string;
-} | {
-    readonly kind: 'historySync';
-    readonly messages: readonly ChatCompletionMessage[];
-} | {
-    readonly kind: 'subagentSpawn';
-    readonly payload: SubAgentSpawnPayload;
-};
-type LlmAgentEcSlice = {
-    readonly projectDir: string;
-    readonly runId: string;
-    readonly nodeId: string;
-    readonly params: Readonly<Record<string, unknown>>;
-    readonly toolHandles?: readonly ToolHandle[];
-    readonly mcpHandles?: readonly import('@langflower/node-sdk/mcp').McpHandle[];
-};
-type ReactiveBindHelpers = {
-    readonly makeInput: typeof makeInput;
-    readonly configureOutput: typeof configureOutput;
-    readonly combineInputs: typeof combineStatefulObservables;
-};
-/** 0 = unlimited; positive = max feedback turns after turn 0. */
-export declare const normalizeMaxFeedbackTurns: (value: unknown) => number;
-export declare const appendToolInventory: (systemPrompt: string, tools: readonly ToolHandle[]) => string;
-/**
- * RxJS operator: filter session chunks by `kind` and project the payload.
- * Use inside `pipeValue` — do not wrap as `(cycle$) => cycle$.pipeValue(...)`.
- *
- * `@rx-evo` wraps values in `NoInfer`, which breaks `Extract` type guards —
- * callers narrow with a cast inside `project`.
- */
-export declare const demuxByKind: <Out>(kind: string, project: (chunk: {
-    readonly kind: string;
-}) => Out) => OperatorFunction<{
-    readonly kind: string;
-}, Out>;
-/**
- * Shared LLM session cycle (ADR-016): init context recreates the session;
- * turn$ drives turn 0 + later turns with accumulated `messages[]`.
- *
- * All LLM nodes (openai / fake / critique / review / future) MUST use this —
- * do not invent per-node cold-start `switchMap` history.
- */
-export declare const createLlmSessionCycle$: <Context extends {
-    readonly maxFeedbackTurns: number;
-    readonly requestPermission?: (request: PermissionAskRequest) => Promise<"allow" | "deny">;
-}, Chunk extends {
-    readonly kind: string;
-}, Session, Deps, Meta>(context$: StatefulObservable<Context, Deps, Meta>, turn$: Observable<unknown>, prepareSession: (context: Context) => LlmFeedbackSessionPrep<Session>, runTurn: (context: Context, turnPayload: unknown, history: readonly ChatCompletionMessage[], session: Session) => Observable<Chunk>, options?: LlmSessionCycleOptions) => StatefulObservable<Chunk, Deps, Meta>;
-type BindLlmAgentSessionOptions<Context extends LlmAgentInventoryContext, Chunk extends StandardLlmAgentChunk, Session> = {
-    readonly extendContext: (base: LlmAgentInventoryContext, ec: LlmAgentEcSlice) => Context;
-    readonly prepareSession: (context: Context) => LlmFeedbackSessionPrep<Session>;
-    readonly runTurn: (context: Context, feedback: string | undefined, history: readonly ChatCompletionMessage[], subagentResult$: Observable<unknown>, session: Session) => Observable<Chunk>;
-};
-/**
- * Composer entry for OpenAI / Fake agent binds.
- *
- * Order:
- * 1. make role inputs (userPrompt / systemPrompt / feedback)
- * 2. assemble inventory context$ (+ provider extend)
- * 3. ADR-016 feedback cycle$
- * 4. demux chunk ports
- * 5. configure standard outputs
- */
-export declare const bindLlmAgentSession: <Context extends LlmAgentInventoryContext, Chunk extends StandardLlmAgentChunk, Session = undefined>(ctx: StatefulObservable<LlmAgentEcSlice, unknown, PortMeta>, helpers: ReactiveBindHelpers, inventory: LlmInventoryInputs, options: BindLlmAgentSessionOptions<Context, Chunk, Session>) => {
-    inputs: import("@rx-evo/stateful-observable").StatefulConnection<string, unknown, import("@langflower/node-sdk").InputPortMeta<string>>[];
-    outputs: StatefulObservable<string, unknown, import("@langflower/node-sdk").OutputParams & PortMeta>[];
-    inventoryOutputs: {
-        toolLog$: StatefulObservable<string, [unknown, unknown, unknown, unknown, unknown, unknown], undefined>;
-        recovery$: StatefulObservable<LlmRecoveryNotice, [unknown, unknown, unknown, unknown, unknown, unknown], undefined>;
-        subagent$: StatefulObservable<SubAgentSpawnPayload, [unknown, unknown, unknown, unknown, unknown, unknown], undefined>;
-    };
-};
-export {};