@n8n/instance-ai 1.0.0

package/dist/types.d.ts

@@ -0,0 +1,709 @@
+import type { LanguageModelV2 } from '@ai-sdk/provider-v5';
+import type { ToolsInput } from '@mastra/core/agent';
+import type { MastraCompositeStore } from '@mastra/core/storage';
+import type { Workspace } from '@mastra/core/workspace';
+import type { Memory } from '@mastra/memory';
+import type { TaskList, InstanceAiPermissions, McpTool, McpToolCallRequest, McpToolCallResult } from '@n8n/api-types';
+import type { WorkflowJSON } from '@n8n/workflow-sdk';
+import type { DomainAccessTracker } from './domain-access/domain-access-tracker';
+import type { InstanceAiEventBus } from './event-bus/event-bus.interface';
+import type { IterationLog } from './storage/iteration-log';
+import type { VerificationResult, WorkflowBuildOutcome, WorkflowLoopAction } from './workflow-loop/workflow-loop-state';
+import type { BuilderSandboxFactory } from './workspace/builder-sandbox-factory';
+export interface WorkflowSummary {
+    id: string;
+    name: string;
+    versionId: string;
+    activeVersionId: string | null;
+    createdAt: string;
+    updatedAt: string;
+    tags?: string[];
+}
+export interface WorkflowDetail extends WorkflowSummary {
+    nodes: WorkflowNode[];
+    connections: Record<string, unknown>;
+    settings?: Record<string, unknown>;
+}
+export interface WorkflowNode {
+    name: string;
+    type: string;
+    parameters?: Record<string, unknown>;
+    position: number[];
+    webhookId?: string;
+}
+export interface ExecutionResult {
+    executionId: string;
+    status: 'running' | 'success' | 'error' | 'waiting' | 'unknown';
+    data?: Record<string, unknown>;
+    error?: string;
+    startedAt?: string;
+    finishedAt?: string;
+}
+export interface NodeOutputResult {
+    nodeName: string;
+    items: unknown[];
+    totalItems: number;
+    returned: {
+        from: number;
+        to: number;
+    };
+}
+export interface ExecutionDebugInfo extends ExecutionResult {
+    failedNode?: {
+        name: string;
+        type: string;
+        error: string;
+        inputData?: Record<string, unknown> | string;
+    };
+    nodeTrace: Array<{
+        name: string;
+        type: string;
+        status: 'success' | 'error';
+        startedAt?: string;
+        finishedAt?: string;
+    }>;
+}
+export interface CredentialSummary {
+    id: string;
+    name: string;
+    type: string;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface CredentialDetail extends CredentialSummary {
+    nodesWithAccess?: Array<{
+        nodeType: string;
+    }>;
+}
+export interface NodeSummary {
+    name: string;
+    displayName: string;
+    description: string;
+    group: string[];
+    version: number;
+}
+export interface NodeDescription extends NodeSummary {
+    properties: Array<{
+        displayName: string;
+        name: string;
+        type: string;
+        required?: boolean;
+        description?: string;
+        default?: unknown;
+        options?: Array<{
+            name: string;
+            value: string | number | boolean;
+        }>;
+    }>;
+    credentials?: Array<{
+        name: string;
+        required?: boolean;
+    }>;
+    inputs: string[];
+    outputs: string[];
+    webhooks?: unknown[];
+    polling?: boolean;
+    triggerPanel?: unknown;
+}
+export interface WorkflowVersionSummary {
+    versionId: string;
+    name: string | null;
+    description: string | null;
+    authors: string;
+    createdAt: string;
+    autosaved: boolean;
+    isActive: boolean;
+    isCurrentDraft: boolean;
+}
+export interface WorkflowVersionDetail extends WorkflowVersionSummary {
+    nodes: WorkflowNode[];
+    connections: Record<string, unknown>;
+}
+export interface InstanceAiWorkflowService {
+    list(options?: {
+        query?: string;
+        limit?: number;
+    }): Promise<WorkflowSummary[]>;
+    get(workflowId: string): Promise<WorkflowDetail>;
+    getAsWorkflowJSON(workflowId: string): Promise<WorkflowJSON>;
+    createFromWorkflowJSON(json: WorkflowJSON, options?: {
+        projectId?: string;
+    }): Promise<WorkflowDetail>;
+    updateFromWorkflowJSON(workflowId: string, json: WorkflowJSON, options?: {
+        projectId?: string;
+    }): Promise<WorkflowDetail>;
+    archive(workflowId: string): Promise<void>;
+    delete(workflowId: string): Promise<void>;
+    publish(workflowId: string, options?: {
+        versionId?: string;
+        name?: string;
+        description?: string;
+    }): Promise<{
+        activeVersionId: string;
+    }>;
+    unpublish(workflowId: string): Promise<void>;
+    listVersions?(workflowId: string, options?: {
+        limit?: number;
+        skip?: number;
+    }): Promise<WorkflowVersionSummary[]>;
+    getVersion?(workflowId: string, versionId: string): Promise<WorkflowVersionDetail>;
+    restoreVersion?(workflowId: string, versionId: string): Promise<void>;
+    updateVersion?(workflowId: string, versionId: string, data: {
+        name?: string | null;
+        description?: string | null;
+    }): Promise<void>;
+}
+export interface ExecutionSummary {
+    id: string;
+    workflowId: string;
+    workflowName: string;
+    status: string;
+    startedAt: string;
+    finishedAt?: string;
+    mode: string;
+}
+export interface InstanceAiExecutionService {
+    list(options?: {
+        workflowId?: string;
+        status?: string;
+        limit?: number;
+    }): Promise<ExecutionSummary[]>;
+    run(workflowId: string, inputData?: Record<string, unknown>, options?: {
+        timeout?: number;
+        pinData?: Record<string, unknown[]>;
+        triggerNodeName?: string;
+    }): Promise<ExecutionResult>;
+    getStatus(executionId: string): Promise<ExecutionResult>;
+    getResult(executionId: string): Promise<ExecutionResult>;
+    stop(executionId: string): Promise<{
+        success: boolean;
+        message: string;
+    }>;
+    getDebugInfo(executionId: string): Promise<ExecutionDebugInfo>;
+    getNodeOutput(executionId: string, nodeName: string, options?: {
+        startIndex?: number;
+        maxItems?: number;
+    }): Promise<NodeOutputResult>;
+}
+export interface CredentialTypeSearchResult {
+    type: string;
+    displayName: string;
+}
+export interface InstanceAiCredentialService {
+    list(options?: {
+        type?: string;
+    }): Promise<CredentialSummary[]>;
+    get(credentialId: string): Promise<CredentialDetail>;
+    delete(credentialId: string): Promise<void>;
+    test(credentialId: string): Promise<{
+        success: boolean;
+        message?: string;
+    }>;
+    isTestable?(credentialType: string): Promise<boolean>;
+    getDocumentationUrl?(credentialType: string): Promise<string | null>;
+    getCredentialFields?(credentialType: string): CredentialFieldInfo[] | Promise<CredentialFieldInfo[]>;
+    searchCredentialTypes?(query: string): Promise<CredentialTypeSearchResult[]>;
+}
+export interface CredentialFieldInfo {
+    name: string;
+    displayName: string;
+    type: string;
+    required: boolean;
+    description?: string;
+}
+export interface ExploreResourcesParams {
+    nodeType: string;
+    version: number;
+    methodName: string;
+    methodType: 'listSearch' | 'loadOptions';
+    credentialType: string;
+    credentialId: string;
+    filter?: string;
+    paginationToken?: string;
+    currentNodeParameters?: Record<string, unknown>;
+}
+export interface ExploreResourcesResult {
+    results: Array<{
+        name: string;
+        value: string | number | boolean;
+        url?: string;
+        description?: string;
+    }>;
+    paginationToken?: unknown;
+}
+export interface InstanceAiNodeService {
+    listAvailable(options?: {
+        query?: string;
+    }): Promise<NodeSummary[]>;
+    getDescription(nodeType: string, version?: number): Promise<NodeDescription>;
+    listSearchable(): Promise<SearchableNodeDescription[]>;
+    getNodeTypeDefinition?(nodeType: string, options?: {
+        version?: string;
+        resource?: string;
+        operation?: string;
+        mode?: string;
+    }): Promise<{
+        content: string;
+        version?: string;
+        error?: string;
+    } | null>;
+    listDiscriminators?(nodeType: string): Promise<{
+        resources: Array<{
+            name: string;
+            operations: string[];
+        }>;
+    } | null>;
+    exploreResources?(params: ExploreResourcesParams): Promise<ExploreResourcesResult>;
+    getParameterIssues?(nodeType: string, typeVersion: number, parameters: Record<string, unknown>): Promise<Record<string, string[]>>;
+    getNodeCredentialTypes?(nodeType: string, typeVersion: number, parameters: Record<string, unknown>, existingCredentials?: Record<string, unknown>): Promise<string[]>;
+}
+export interface SearchableNodeDescription {
+    name: string;
+    displayName: string;
+    description: string;
+    version: number | number[];
+    inputs: string[] | string;
+    outputs: string[] | string;
+    codex?: {
+        alias?: string[];
+    };
+    builderHint?: {
+        message?: string;
+        inputs?: Record<string, {
+            required: boolean;
+            displayOptions?: Record<string, unknown>;
+        }>;
+    };
+}
+export interface DataTableSummary {
+    id: string;
+    name: string;
+    projectId?: string;
+    columns: Array<{
+        id: string;
+        name: string;
+        type: string;
+    }>;
+    createdAt: string;
+    updatedAt: string;
+}
+export interface DataTableColumnInfo {
+    id: string;
+    name: string;
+    type: 'string' | 'number' | 'boolean' | 'date';
+    index: number;
+}
+export interface DataTableFilterInput {
+    type: 'and' | 'or';
+    filters: Array<{
+        columnName: string;
+        condition: 'eq' | 'neq' | 'like' | 'gt' | 'gte' | 'lt' | 'lte';
+        value: string | number | boolean | null;
+    }>;
+}
+export interface InstanceAiDataTableService {
+    list(options?: {
+        projectId?: string;
+    }): Promise<DataTableSummary[]>;
+    create(name: string, columns: Array<{
+        name: string;
+        type: 'string' | 'number' | 'boolean' | 'date';
+    }>, options?: {
+        projectId?: string;
+    }): Promise<DataTableSummary>;
+    delete(dataTableId: string): Promise<void>;
+    getSchema(dataTableId: string): Promise<DataTableColumnInfo[]>;
+    addColumn(dataTableId: string, column: {
+        name: string;
+        type: 'string' | 'number' | 'boolean' | 'date';
+    }): Promise<DataTableColumnInfo>;
+    deleteColumn(dataTableId: string, columnId: string): Promise<void>;
+    renameColumn(dataTableId: string, columnId: string, newName: string): Promise<void>;
+    queryRows(dataTableId: string, options?: {
+        filter?: DataTableFilterInput;
+        limit?: number;
+        offset?: number;
+    }): Promise<{
+        count: number;
+        data: Array<Record<string, unknown>>;
+    }>;
+    insertRows(dataTableId: string, rows: Array<Record<string, unknown>>): Promise<{
+        insertedCount: number;
+    }>;
+    updateRows(dataTableId: string, filter: DataTableFilterInput, data: Record<string, unknown>): Promise<{
+        updatedCount: number;
+    }>;
+    deleteRows(dataTableId: string, filter: DataTableFilterInput): Promise<{
+        deletedCount: number;
+    }>;
+}
+export interface FetchedPage {
+    url: string;
+    finalUrl: string;
+    title: string;
+    content: string;
+    truncated: boolean;
+    contentLength: number;
+    safetyFlags?: {
+        jsRenderingSuspected?: boolean;
+        loginRequired?: boolean;
+    };
+}
+export interface WebSearchResult {
+    title: string;
+    url: string;
+    snippet: string;
+    publishedDate?: string;
+}
+export interface WebSearchResponse {
+    query: string;
+    results: WebSearchResult[];
+}
+export interface InstanceAiWebResearchService {
+    search?(query: string, options?: {
+        maxResults?: number;
+        includeDomains?: string[];
+        excludeDomains?: string[];
+    }): Promise<WebSearchResponse>;
+    fetchUrl(url: string, options?: {
+        maxContentLength?: number;
+        maxResponseBytes?: number;
+        timeoutMs?: number;
+        authorizeUrl?: (url: string) => Promise<void>;
+    }): Promise<FetchedPage>;
+}
+export interface FileEntry {
+    path: string;
+    type: 'file' | 'directory';
+    sizeBytes?: number;
+}
+export interface FileContent {
+    path: string;
+    content: string;
+    truncated: boolean;
+    totalLines: number;
+}
+export interface FileSearchMatch {
+    path: string;
+    lineNumber: number;
+    line: string;
+}
+export interface FileSearchResult {
+    query: string;
+    matches: FileSearchMatch[];
+    truncated: boolean;
+    totalMatches: number;
+}
+export interface InstanceAiFilesystemService {
+    listFiles(dirPath: string, opts?: {
+        pattern?: string;
+        maxResults?: number;
+        type?: 'file' | 'directory' | 'all';
+        recursive?: boolean;
+    }): Promise<FileEntry[]>;
+    readFile(filePath: string, opts?: {
+        maxLines?: number;
+        startLine?: number;
+    }): Promise<FileContent>;
+    searchFiles(dirPath: string, opts: {
+        query: string;
+        filePattern?: string;
+        ignoreCase?: boolean;
+        maxResults?: number;
+    }): Promise<FileSearchResult>;
+    getFileTree(dirPath: string, opts?: {
+        maxDepth?: number;
+        exclude?: string[];
+    }): Promise<string>;
+}
+export interface LocalMcpServer {
+    getAvailableTools(): McpTool[];
+    getToolsByCategory(category: string): McpTool[];
+    callTool(req: McpToolCallRequest): Promise<McpToolCallResult>;
+}
+export interface ProjectSummary {
+    id: string;
+    name: string;
+    type: 'personal' | 'team';
+}
+export interface FolderSummary {
+    id: string;
+    name: string;
+    parentFolderId: string | null;
+}
+export interface InstanceAiWorkspaceService {
+    getProject?(projectId: string): Promise<ProjectSummary | null>;
+    listProjects(): Promise<ProjectSummary[]>;
+    listFolders?(projectId: string): Promise<FolderSummary[]>;
+    createFolder?(name: string, projectId: string, parentFolderId?: string): Promise<FolderSummary>;
+    deleteFolder?(folderId: string, projectId: string, transferToFolderId?: string): Promise<void>;
+    moveWorkflowToFolder?(workflowId: string, folderId: string): Promise<void>;
+    tagWorkflow(workflowId: string, tagNames: string[]): Promise<string[]>;
+    listTags(): Promise<Array<{
+        id: string;
+        name: string;
+    }>>;
+    createTag(name: string): Promise<{
+        id: string;
+        name: string;
+    }>;
+    cleanupTestExecutions(workflowId: string, options?: {
+        olderThanHours?: number;
+    }): Promise<{
+        deletedCount: number;
+    }>;
+}
+export type LocalGatewayStatus = {
+    status: 'connected';
+} | {
+    status: 'disconnected';
+    capabilities: string[];
+} | {
+    status: 'disabled';
+};
+export interface InstanceAiContext {
+    userId: string;
+    workflowService: InstanceAiWorkflowService;
+    executionService: InstanceAiExecutionService;
+    credentialService: InstanceAiCredentialService;
+    nodeService: InstanceAiNodeService;
+    dataTableService: InstanceAiDataTableService;
+    webResearchService?: InstanceAiWebResearchService;
+    filesystemService?: InstanceAiFilesystemService;
+    workspaceService?: InstanceAiWorkspaceService;
+    localMcpServer?: LocalMcpServer;
+    localGatewayStatus?: LocalGatewayStatus;
+    permissions?: InstanceAiPermissions;
+    licenseHints?: string[];
+    domainAccessTracker?: DomainAccessTracker;
+    runId?: string;
+}
+export interface TaskStorage {
+    get(threadId: string): Promise<TaskList | null>;
+    save(threadId: string, tasks: TaskList): Promise<void>;
+}
+export type PlannedTaskKind = 'delegate' | 'build-workflow' | 'manage-data-tables' | 'research';
+export interface PlannedTask {
+    id: string;
+    title: string;
+    kind: PlannedTaskKind;
+    spec: string;
+    deps: string[];
+    tools?: string[];
+    workflowId?: string;
+}
+export type PlannedTaskStatus = 'planned' | 'running' | 'succeeded' | 'failed' | 'cancelled';
+export interface PlannedTaskRecord extends PlannedTask {
+    status: PlannedTaskStatus;
+    agentId?: string;
+    backgroundTaskId?: string;
+    result?: string;
+    error?: string;
+    outcome?: Record<string, unknown>;
+    startedAt?: number;
+    finishedAt?: number;
+}
+export type PlannedTaskGraphStatus = 'active' | 'awaiting_replan' | 'completed' | 'cancelled';
+export interface PlannedTaskGraph {
+    planRunId: string;
+    messageGroupId?: string;
+    status: PlannedTaskGraphStatus;
+    tasks: PlannedTaskRecord[];
+}
+export type PlannedTaskSchedulerAction = {
+    type: 'none';
+    graph: PlannedTaskGraph | null;
+} | {
+    type: 'dispatch';
+    graph: PlannedTaskGraph;
+    tasks: PlannedTaskRecord[];
+} | {
+    type: 'replan';
+    graph: PlannedTaskGraph;
+    failedTask: PlannedTaskRecord;
+} | {
+    type: 'synthesize';
+    graph: PlannedTaskGraph;
+};
+export interface PlannedTaskService {
+    createPlan(threadId: string, tasks: PlannedTask[], metadata: {
+        planRunId: string;
+        messageGroupId?: string;
+    }): Promise<PlannedTaskGraph>;
+    getGraph(threadId: string): Promise<PlannedTaskGraph | null>;
+    markRunning(threadId: string, taskId: string, update: {
+        agentId?: string;
+        backgroundTaskId?: string;
+        startedAt?: number;
+    }): Promise<PlannedTaskGraph | null>;
+    markSucceeded(threadId: string, taskId: string, update: {
+        result?: string;
+        outcome?: Record<string, unknown>;
+        finishedAt?: number;
+    }): Promise<PlannedTaskGraph | null>;
+    markFailed(threadId: string, taskId: string, update: {
+        error?: string;
+        finishedAt?: number;
+    }): Promise<PlannedTaskGraph | null>;
+    markCancelled(threadId: string, taskId: string, update?: {
+        error?: string;
+        finishedAt?: number;
+    }): Promise<PlannedTaskGraph | null>;
+    tick(threadId: string, options?: {
+        availableSlots?: number;
+    }): Promise<PlannedTaskSchedulerAction>;
+    clear(threadId: string): Promise<void>;
+}
+export interface McpServerConfig {
+    name: string;
+    url?: string;
+    command?: string;
+    args?: string[];
+    env?: Record<string, string>;
+}
+export interface InstanceAiMemoryConfig {
+    storage: MastraCompositeStore;
+    embedderModel?: string;
+    lastMessages?: number;
+    semanticRecallTopK?: number;
+    threadTtlDays?: number;
+}
+export type ModelConfig = string | {
+    id: `${string}/${string}`;
+    url: string;
+    apiKey?: string;
+    headers?: Record<string, string>;
+} | LanguageModelV2;
+export interface ServiceProxyConfig {
+    apiUrl: string;
+    headers: Record<string, string>;
+}
+export interface InstanceAiTraceRun {
+    id: string;
+    name: string;
+    runType: string;
+    projectName: string;
+    startTime: number;
+    endTime?: number;
+    traceId: string;
+    dottedOrder: string;
+    executionOrder: number;
+    childExecutionOrder: number;
+    parentRunId?: string;
+    tags?: string[];
+    metadata?: Record<string, unknown>;
+    inputs?: Record<string, unknown>;
+    outputs?: Record<string, unknown>;
+    error?: string;
+}
+export interface InstanceAiTraceRunInit {
+    name: string;
+    runType?: string;
+    tags?: string[];
+    metadata?: Record<string, unknown>;
+    inputs?: unknown;
+}
+export interface InstanceAiTraceRunFinishOptions {
+    outputs?: unknown;
+    metadata?: Record<string, unknown>;
+    error?: string;
+}
+export interface InstanceAiToolTraceOptions {
+    agentRole?: string;
+    tags?: string[];
+    metadata?: Record<string, unknown>;
+}
+export interface InstanceAiTraceContext {
+    projectName: string;
+    traceKind: 'message_turn' | 'detached_subagent';
+    rootRun: InstanceAiTraceRun;
+    actorRun: InstanceAiTraceRun;
+    messageRun: InstanceAiTraceRun;
+    orchestratorRun: InstanceAiTraceRun;
+    startChildRun: (parentRun: InstanceAiTraceRun, options: InstanceAiTraceRunInit) => Promise<InstanceAiTraceRun>;
+    withRunTree: <T>(run: InstanceAiTraceRun, fn: () => Promise<T>) => Promise<T>;
+    finishRun: (run: InstanceAiTraceRun, options?: InstanceAiTraceRunFinishOptions) => Promise<void>;
+    failRun: (run: InstanceAiTraceRun, error: unknown, metadata?: Record<string, unknown>) => Promise<void>;
+    toHeaders: (run: InstanceAiTraceRun) => Record<string, string>;
+    wrapTools: (tools: ToolsInput, options?: InstanceAiToolTraceOptions) => ToolsInput;
+}
+export interface BackgroundTaskResult {
+    text: string;
+    outcome?: Record<string, unknown>;
+}
+export interface SpawnBackgroundTaskOptions {
+    taskId: string;
+    threadId: string;
+    agentId: string;
+    role: string;
+    traceContext?: InstanceAiTraceContext;
+    plannedTaskId?: string;
+    workItemId?: string;
+    run: (signal: AbortSignal, drainCorrections: () => string[]) => Promise<string | BackgroundTaskResult>;
+}
+export interface WorkflowTaskService {
+    reportBuildOutcome(outcome: WorkflowBuildOutcome): Promise<WorkflowLoopAction>;
+    reportVerificationVerdict(verdict: VerificationResult): Promise<WorkflowLoopAction>;
+    getBuildOutcome(workItemId: string): Promise<WorkflowBuildOutcome | undefined>;
+    updateBuildOutcome(workItemId: string, update: Partial<WorkflowBuildOutcome>): Promise<void>;
+}
+export interface OrchestrationContext {
+    threadId: string;
+    runId: string;
+    messageGroupId?: string;
+    userId: string;
+    orchestratorAgentId: string;
+    modelId: ModelConfig;
+    storage: MastraCompositeStore;
+    subAgentMaxSteps: number;
+    eventBus: InstanceAiEventBus;
+    domainTools: ToolsInput;
+    abortSignal: AbortSignal;
+    taskStorage: TaskStorage;
+    tracing?: InstanceAiTraceContext;
+    waitForConfirmation?: (requestId: string) => Promise<{
+        approved: boolean;
+        credentialId?: string;
+        credentials?: Record<string, string>;
+        autoSetup?: {
+            credentialType: string;
+        };
+        userInput?: string;
+        domainAccessAction?: string;
+        answers?: Array<{
+            questionId: string;
+            selectedOptions: string[];
+            customText?: string;
+            skipped?: boolean;
+        }>;
+    }>;
+    browserMcpConfig?: McpServerConfig;
+    localMcpServer?: LocalMcpServer;
+    mcpTools?: ToolsInput;
+    oauth2CallbackUrl?: string;
+    webhookBaseUrl?: string;
+    spawnBackgroundTask?: (opts: SpawnBackgroundTaskOptions) => void;
+    cancelBackgroundTask?: (taskId: string) => Promise<void>;
+    plannedTaskService?: PlannedTaskService;
+    schedulePlannedTasks?: () => Promise<void>;
+    workspace?: Workspace;
+    builderSandboxFactory?: BuilderSandboxFactory;
+    nodeDefinitionDirs?: string[];
+    domainContext?: InstanceAiContext;
+    researchMode?: boolean;
+    iterationLog?: IterationLog;
+    sendCorrectionToTask?: (taskId: string, correction: string) => 'queued' | 'task-completed' | 'task-not-found';
+    workflowTaskService?: WorkflowTaskService;
+    tracingProxyConfig?: ServiceProxyConfig;
+}
+export interface CreateInstanceAgentOptions {
+    modelId: ModelConfig;
+    context: InstanceAiContext;
+    orchestrationContext?: OrchestrationContext;
+    mcpServers?: McpServerConfig[];
+    memoryConfig: InstanceAiMemoryConfig;
+    memory?: Memory;
+    workspace?: Workspace;
+    disableDeferredTools?: boolean;
+    timeZone?: string;
+}

package/dist/types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

package/dist/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":""}