zeitlich 0.2.13 → 0.2.14

package/dist/types-BMXzv7TN.d.ts

@@ -0,0 +1,476 @@
+import { z } from 'zod';
+
+/** A single content part within a structured message (text, image, etc.) */
+type ContentPart = {
+    type: string;
+    [key: string]: unknown;
+};
+/** Message content — plain string or an array of structured content parts */
+type MessageContent = string | ContentPart[];
+/** Content returned by a tool handler */
+type ToolMessageContent = MessageContent;
+/**
+ * Agent execution status
+ */
+type AgentStatus = "RUNNING" | "WAITING_FOR_INPUT" | "COMPLETED" | "FAILED" | "CANCELLED";
+/**
+ * Base state that all agents must have
+ */
+interface BaseAgentState {
+    tools: SerializableToolDefinition[];
+    status: AgentStatus;
+    version: number;
+    turns: number;
+    tasks: Map<string, WorkflowTask>;
+    systemPrompt?: string;
+    totalInputTokens: number;
+    totalOutputTokens: number;
+    cachedWriteTokens: number;
+    cachedReadTokens: number;
+}
+/**
+ * File representation for agent workflows
+ */
+interface AgentFile {
+    /** Database/S3 file ID */
+    id: string;
+    /** Virtual path for agent (e.g., "evidence/invoice.pdf") */
+    path: string;
+    /** Original filename */
+    filename: string;
+    /** Generic description for prompt */
+    description?: string;
+    /** MIME type of the file */
+    mimeType?: string;
+}
+interface TokenUsage {
+    inputTokens?: number;
+    outputTokens?: number;
+    cachedWriteTokens?: number;
+    cachedReadTokens?: number;
+    reasonTokens?: number;
+}
+/**
+ * Configuration for a Zeitlich agent
+ */
+interface AgentConfig {
+    /** The name of the agent, should be unique within the workflows, ideally Pascal Case */
+    agentName: string;
+    /** Description, used for sub agents */
+    description?: string;
+}
+/**
+ * A JSON-serializable tool definition for state storage.
+ * Uses a plain JSON Schema object instead of a live Zod instance,
+ * so it survives Temporal serialization without losing constraints (min, max, etc.).
+ */
+interface SerializableToolDefinition {
+    name: string;
+    description: string;
+    schema: Record<string, unknown>;
+    strict?: boolean;
+    max_uses?: number;
+}
+/**
+ * Configuration passed to runAgent activity
+ */
+interface RunAgentConfig extends AgentConfig {
+    /** The thread ID to use for the session */
+    threadId: string;
+    /** Metadata for the session */
+    metadata?: Record<string, unknown>;
+}
+/**
+ * Configuration for appending a tool result
+ */
+interface ToolResultConfig {
+    threadId: string;
+    toolCallId: string;
+    /** The name of the tool that produced this result */
+    toolName: string;
+    /** Content for the tool message (string or complex content parts) */
+    content: ToolMessageContent;
+}
+/**
+ * Status of a workflow task
+ */
+type TaskStatus = "pending" | "in_progress" | "completed";
+/**
+ * A task managed within a workflow for tracking work items
+ */
+interface WorkflowTask {
+    /** Unique task identifier */
+    id: string;
+    /** Brief, actionable title in imperative form */
+    subject: string;
+    /** Detailed description of what needs to be done */
+    description: string;
+    /** Present continuous form shown in spinner when in_progress */
+    activeForm: string;
+    /** Current status of the task */
+    status: TaskStatus;
+    /** Arbitrary key-value pairs for tracking */
+    metadata: Record<string, string>;
+    /** IDs of tasks that must complete before this one can start */
+    blockedBy: string[];
+    /** IDs of tasks that are waiting for this one to complete */
+    blocks: string[];
+}
+/**
+ * Exit reasons for session termination
+ */
+type SessionExitReason = "completed" | "max_turns" | "waiting_for_input" | "failed" | "cancelled";
+/**
+ * Helper to check if status is terminal
+ */
+declare function isTerminalStatus(status: AgentStatus): boolean;
+
+/**
+ * A tool definition with a name, description, and Zod schema for arguments.
+ * Does not include a handler - use ToolWithHandler for tools with handlers.
+ */
+interface ToolDefinition<TName extends string = string, TSchema extends z.ZodType = z.ZodType> {
+    name: TName;
+    description: string;
+    schema: TSchema;
+    strict?: boolean;
+    max_uses?: number;
+}
+/**
+ * A tool definition with an integrated handler function.
+ * This is the primary type for defining tools in the router.
+ */
+interface ToolWithHandler<TName extends string = string, TSchema extends z.ZodType = z.ZodType, TResult = unknown, TContext extends RouterContext = RouterContext> {
+    name: TName;
+    description: string;
+    schema: TSchema;
+    handler: ToolHandler<z.infer<TSchema>, TResult, TContext>;
+    strict?: boolean;
+    max_uses?: number;
+    /** Whether this tool is available to the agent (default: true). Disabled tools are excluded from definitions and rejected at parse time. */
+    enabled?: boolean;
+    /** Per-tool lifecycle hooks (run in addition to global hooks) */
+    hooks?: ToolHooks<z.infer<TSchema>, TResult>;
+}
+/**
+ * A map of tool keys to tool definitions with handlers.
+ *
+ * Handler uses `any` intentionally — this is a type-system boundary where heterogeneous
+ * tool types are stored together. Type safety for individual tools is enforced by
+ * `defineTool()` at the definition site and generic inference utilities like
+ * `InferToolResults<T>` at the consumption site.
+ */
+type ToolMap = Record<string, {
+    name: string;
+    description: string;
+    schema: z.ZodType;
+    handler: ToolHandler<any, any, any>;
+    strict?: boolean;
+    max_uses?: number;
+    enabled?: boolean;
+    hooks?: ToolHooks<any, any>;
+}>;
+/**
+ * Extract the tool names from a tool map (uses the tool's name property, not the key).
+ */
+type ToolNames<T extends ToolMap> = T[keyof T]["name"];
+/**
+ * A raw tool call as received from the LLM before parsing.
+ */
+interface RawToolCall {
+    id?: string;
+    name: string;
+    args: unknown;
+}
+/**
+ * A parsed tool call with validated arguments for a specific tool.
+ */
+interface ParsedToolCall<TName extends string = string, TArgs = unknown> {
+    id: string;
+    name: TName;
+    args: TArgs;
+}
+/**
+ * Union type of all possible parsed tool calls from a tool map.
+ */
+type ParsedToolCallUnion<T extends ToolMap> = {
+    [K in keyof T]: ParsedToolCall<T[K]["name"], z.infer<T[K]["schema"]>>;
+}[keyof T];
+/**
+ * Function signature for appending tool results to a thread.
+ */
+type AppendToolResultFn = (config: ToolResultConfig) => Promise<void>;
+/**
+ * The response from a tool handler.
+ * Contains the content for the tool message and the result to return from processToolCalls.
+ *
+ * Tools that don't return additional data should use `data: null` (TResult defaults to null).
+ * Tools that may fail to produce data should type TResult as `SomeType | null`.
+ */
+interface ToolHandlerResponse<TResult = null> {
+    /** Content sent back to the LLM as the tool call response */
+    toolResponse: ToolMessageContent;
+    /** Data returned to the workflow and hooks for further processing */
+    data: TResult;
+    /**
+     * When true, the tool result has already been appended to the thread
+     * by the handler itself (e.g. via `withAutoAppend`), so the router
+     * will skip the `appendToolResult` call. This avoids sending large
+     * payloads through Temporal's activity payload limit.
+     */
+    resultAppended?: boolean;
+    /** Token usage from the tool execution (e.g. child agent invocations) */
+    usage?: TokenUsage;
+    /** Thread ID used by the handler (surfaced to the LLM for subagent thread continuation) */
+    threadId?: string;
+}
+/**
+ * Base context the router always injects into every handler invocation.
+ * Handlers can rely on these fields being present without casting.
+ */
+interface RouterContext {
+    threadId: string;
+    toolCallId: string;
+    toolName: string;
+    sandboxId?: string;
+}
+/**
+ * A handler function for a specific tool.
+ * Receives the parsed args and a context that always includes {@link RouterContext}
+ * fields, plus any additional properties when TContext extends RouterContext.
+ */
+type ToolHandler<TArgs, TResult, TContext extends RouterContext = RouterContext> = (args: TArgs, context: TContext) => ToolHandlerResponse<TResult> | Promise<ToolHandlerResponse<TResult>>;
+/**
+ * Activity-compatible tool handler that always returns a Promise.
+ * Use this for tool handlers registered as Temporal activities.
+ *
+ * @example
+ * ```typescript
+ * const readHandler: ActivityToolHandler<
+ *   FileReadArgs,
+ *   ReadResult,
+ *   RouterContext & { scopedNodes: FileNode[]; provider: FileSystemProvider }
+ * > = async (args, context) => {
+ *   // context.threadId, context.sandboxId etc. are always available
+ *   return readHandler(args, context.scopedNodes, context.provider);
+ * };
+ * ```
+ */
+type ActivityToolHandler<TArgs, TResult, TContext extends RouterContext = RouterContext> = (args: TArgs, context: TContext) => Promise<ToolHandlerResponse<TResult>>;
+/**
+ * Extract the args type for a specific tool name from a tool map.
+ */
+type ToolArgs<T extends ToolMap, TName extends ToolNames<T>> = z.infer<Extract<T[keyof T], {
+    name: TName;
+}>["schema"]>;
+/**
+ * Extract the result type for a specific tool name from a tool map.
+ */
+type ToolResult<T extends ToolMap, TName extends ToolNames<T>> = Extract<T[keyof T], {
+    name: TName;
+}>["handler"] extends ToolHandler<unknown, infer R, RouterContext> ? Awaited<R> : never;
+/**
+ * The result of processing a tool call.
+ */
+interface ToolCallResult<TName extends string = string, TResult = unknown> {
+    toolCallId: string;
+    name: TName;
+    data: TResult;
+    usage?: TokenUsage;
+}
+/**
+ * Infer result types from a tool map based on handler return types.
+ */
+type InferToolResults<T extends ToolMap> = {
+    [K in keyof T as T[K]["name"]]: T[K]["handler"] extends ToolHandler<any, infer R, any> ? Awaited<R> : never;
+};
+/**
+ * Union of all possible tool call results based on handler return types.
+ */
+type ToolCallResultUnion<TResults extends Record<string, unknown>> = {
+    [TName in keyof TResults & string]: ToolCallResult<TName, TResults[TName]>;
+}[keyof TResults & string];
+/**
+ * Context passed to processToolCalls for hook execution and handler invocation
+ */
+interface ProcessToolCallsContext {
+    /** Current turn number (for hooks) */
+    turn?: number;
+    /** Active sandbox ID (when a sandbox is configured for this session) */
+    sandboxId?: string;
+}
+/**
+ * Result from PreToolUse hook - can block or modify execution
+ */
+interface PreToolUseHookResult {
+    /** Skip this tool call entirely */
+    skip?: boolean;
+    /** Modified args to use instead (must match schema) */
+    modifiedArgs?: unknown;
+}
+/**
+ * Result from PostToolUseFailure hook - can recover from errors
+ */
+interface PostToolUseFailureHookResult {
+    /** Provide a fallback result instead of throwing */
+    fallbackContent?: ToolMessageContent;
+    /** Whether to suppress the error (still logs, but continues) */
+    suppress?: boolean;
+}
+/**
+ * Per-tool lifecycle hooks - defined directly on a tool definition.
+ * Runs in addition to global hooks (global pre → tool pre → execute → tool post → global post).
+ */
+interface ToolHooks<TArgs = unknown, TResult = unknown> {
+    /** Called before this tool executes - can skip or modify args */
+    onPreToolUse?: (ctx: {
+        args: TArgs;
+        threadId: string;
+        turn: number;
+    }) => PreToolUseHookResult | Promise<PreToolUseHookResult>;
+    /** Called after this tool executes successfully */
+    onPostToolUse?: (ctx: {
+        args: TArgs;
+        result: TResult;
+        threadId: string;
+        turn: number;
+        durationMs: number;
+    }) => void | Promise<void>;
+    /** Called when this tool execution fails */
+    onPostToolUseFailure?: (ctx: {
+        args: TArgs;
+        error: Error;
+        threadId: string;
+        turn: number;
+    }) => PostToolUseFailureHookResult | Promise<PostToolUseFailureHookResult>;
+}
+/**
+ * Context for PreToolUse hook - called before tool execution
+ */
+interface PreToolUseHookContext<T extends ToolMap> {
+    /** The tool call about to be executed */
+    toolCall: ParsedToolCallUnion<T>;
+    /** Thread identifier */
+    threadId: string;
+    /** Current turn number */
+    turn: number;
+}
+/**
+ * PreToolUse hook - called before tool execution, can block or modify
+ */
+type PreToolUseHook<T extends ToolMap> = (ctx: PreToolUseHookContext<T>) => PreToolUseHookResult | Promise<PreToolUseHookResult>;
+/**
+ * Context for PostToolUse hook - called after successful tool execution
+ */
+interface PostToolUseHookContext<T extends ToolMap, TResult = unknown> {
+    /** The tool call that was executed */
+    toolCall: ParsedToolCallUnion<T>;
+    /** The result from the tool handler */
+    result: TResult;
+    /** Thread identifier */
+    threadId: string;
+    /** Current turn number */
+    turn: number;
+    /** Execution duration in milliseconds */
+    durationMs: number;
+}
+/**
+ * PostToolUse hook - called after successful tool execution
+ */
+type PostToolUseHook<T extends ToolMap, TResult = unknown> = (ctx: PostToolUseHookContext<T, TResult>) => void | Promise<void>;
+/**
+ * Context for PostToolUseFailure hook - called when tool execution fails
+ */
+interface PostToolUseFailureHookContext<T extends ToolMap> {
+    /** The tool call that failed */
+    toolCall: ParsedToolCallUnion<T>;
+    /** The error that occurred */
+    error: Error;
+    /** Thread identifier */
+    threadId: string;
+    /** Current turn number */
+    turn: number;
+}
+/**
+ * PostToolUseFailure hook - called when tool execution fails
+ */
+type PostToolUseFailureHook<T extends ToolMap> = (ctx: PostToolUseFailureHookContext<T>) => PostToolUseFailureHookResult | Promise<PostToolUseFailureHookResult>;
+/**
+ * Tool execution hooks — the subset of hooks consumed by the tool router.
+ * Session/message lifecycle hooks live in lib/hooks/types.ts.
+ */
+interface ToolRouterHooks<T extends ToolMap, TResult = unknown> {
+    /** Called before each tool execution - can block or modify */
+    onPreToolUse?: PreToolUseHook<T>;
+    /** Called after each successful tool execution */
+    onPostToolUse?: PostToolUseHook<T, TResult>;
+    /** Called when tool execution fails */
+    onPostToolUseFailure?: PostToolUseFailureHook<T>;
+}
+/**
+ * Options for creating a tool router.
+ */
+interface ToolRouterOptions<T extends ToolMap> {
+    /** Map of tools with their handlers */
+    tools: T;
+    /** Thread ID for appending tool results */
+    threadId: string;
+    /** Function to append tool results to the thread (called automatically after each handler) */
+    appendToolResult: AppendToolResultFn;
+    /** Whether to process tools in parallel (default: true) */
+    parallel?: boolean;
+    /** Tool execution lifecycle hooks (pre/post tool use) */
+    hooks?: ToolRouterHooks<T, ToolCallResultUnion<InferToolResults<T>>>;
+    /** Additional tools to auto-register (e.g. subagent, skill tools built by register helpers) */
+    plugins?: ToolMap[string][];
+}
+/**
+ * The tool router interface with full type inference for both args and results.
+ */
+interface ToolRouter<T extends ToolMap> {
+    /** Check if the router has any tools */
+    hasTools(): boolean;
+    /**
+     * Parse and validate a raw tool call against the router's tools.
+     * Returns a typed tool call with validated arguments.
+     */
+    parseToolCall(toolCall: RawToolCall): ParsedToolCallUnion<T>;
+    /**
+     * Check if a tool with the given name exists in the router.
+     */
+    hasTool(name: string): boolean;
+    /**
+     * Get all tool names in the router.
+     */
+    getToolNames(): ToolNames<T>[];
+    /**
+     * Get all tool definitions (without handlers) for passing to LLM.
+     */
+    getToolDefinitions(): ToolDefinition[];
+    /**
+     * Process all tool calls using the registered handlers.
+     * Returns typed results based on handler return types.
+     * @param toolCalls - Array of parsed tool calls to process
+     * @param context - Optional context including turn number for hooks
+     */
+    processToolCalls(toolCalls: ParsedToolCallUnion<T>[], context?: ProcessToolCallsContext): Promise<ToolCallResultUnion<InferToolResults<T>>[]>;
+    /**
+     * Process tool calls matching a specific name with a custom handler.
+     * Useful for overriding the default handler for specific cases.
+     */
+    processToolCallsByName<TName extends ToolNames<T>, TResult>(toolCalls: ParsedToolCallUnion<T>[], toolName: TName, handler: ToolHandler<ToolArgs<T, TName>, TResult>, context?: ProcessToolCallsContext): Promise<ToolCallResult<TName, TResult>[]>;
+    /**
+     * Filter tool calls by name.
+     */
+    filterByName<TName extends ToolNames<T>>(toolCalls: ParsedToolCallUnion<T>[], name: TName): ParsedToolCall<TName, ToolArgs<T, TName>>[];
+    /**
+     * Check if any tool call matches the given name.
+     */
+    hasToolCall(toolCalls: ParsedToolCallUnion<T>[], name: ToolNames<T>): boolean;
+    /**
+     * Filter results by tool name.
+     */
+    getResultsByName<TName extends ToolNames<T>>(results: ToolCallResultUnion<InferToolResults<T>>[], name: TName): ToolCallResult<TName, ToolResult<T, TName>>[];
+}
+
+export { type ActivityToolHandler as A, type BaseAgentState as B, type ContentPart as C, type ToolCallResult as D, type ToolHandler as E, type ToolHooks as F, type ToolNames as G, type ToolResult as H, type InferToolResults as I, type ToolRouter as J, type ToolWithHandler as K, isTerminalStatus as L, type MessageContent as M, type ToolRouterOptions as N, type PreToolUseHookResult as P, type RouterContext as R, type SessionExitReason as S, type ToolMessageContent as T, type WorkflowTask as W, type ToolMap as a, type ToolRouterHooks as b, type ToolHandlerResponse as c, type PostToolUseFailureHookResult as d, type RawToolCall as e, type TokenUsage as f, type RunAgentConfig as g, type AgentStatus as h, type ToolDefinition as i, type ToolResultConfig as j, type ToolCallResultUnion as k, type AgentConfig as l, type AgentFile as m, type AppendToolResultFn as n, type ParsedToolCall as o, type ParsedToolCallUnion as p, type PostToolUseFailureHook as q, type PostToolUseFailureHookContext as r, type PostToolUseHook as s, type PostToolUseHookContext as t, type PreToolUseHook as u, type PreToolUseHookContext as v, type ProcessToolCallsContext as w, type SerializableToolDefinition as x, type TaskStatus as y, type ToolArgs as z };

package/dist/types-BVP87m_W.d.cts

@@ -0,0 +1,121 @@
+import { a as SandboxFileSystem, F as FileStat, D as DirentEntry, S as Sandbox, d as SandboxCreateOptions } from './types-CDubRtad.cjs';
+import { R as RouterContext } from './types-BMXzv7TN.cjs';
+
+/**
+ * Ephemeral {@link SandboxFileSystem} backed by a {@link FileResolver}.
+ *
+ * Created fresh for each tool invocation from the current workflow file tree.
+ * Directory structure is inferred from file paths. All mutations are tracked
+ * and can be retrieved via {@link getMutations} after the handler completes.
+ */
+declare class VirtualSandboxFileSystem<TCtx = unknown, TMeta = FileEntryMetadata> implements SandboxFileSystem {
+    private resolver;
+    private ctx;
+    private entries;
+    private directories;
+    private mutations;
+    constructor(tree: FileEntry<TMeta>[], resolver: FileResolver<TCtx, TMeta>, ctx: TCtx);
+    /** Return all mutations accumulated during this invocation. */
+    getMutations(): TreeMutation<TMeta>[];
+    /** Look up a file entry by virtual path. */
+    getEntry(path: string): FileEntry<TMeta> | undefined;
+    readFile(path: string): Promise<string>;
+    readFileBuffer(path: string): Promise<Uint8Array>;
+    exists(path: string): Promise<boolean>;
+    stat(path: string): Promise<FileStat>;
+    readdir(path: string): Promise<string[]>;
+    readdirWithFileTypes(path: string): Promise<DirentEntry[]>;
+    writeFile(path: string, content: string | Uint8Array): Promise<void>;
+    appendFile(path: string, content: string | Uint8Array): Promise<void>;
+    mkdir(_path: string, _options?: {
+        recursive?: boolean;
+    }): Promise<void>;
+    rm(path: string, options?: {
+        recursive?: boolean;
+        force?: boolean;
+    }): Promise<void>;
+    cp(src: string, dest: string, _options?: {
+        recursive?: boolean;
+    }): Promise<void>;
+    mv(src: string, dest: string): Promise<void>;
+    readlink(_path: string): Promise<string>;
+    resolvePath(base: string, path: string): string;
+    private addParentDirectories;
+}
+
+/** Allowed value types for file-entry metadata. */
+type FileEntryMetadata = Record<string, string | number | boolean | null>;
+/** JSON-serializable metadata for a single file in the virtual tree. */
+interface FileEntry<TMeta = FileEntryMetadata> {
+    id: string;
+    /** Virtual path inside the sandbox, e.g. "/src/index.ts" */
+    path: string;
+    size: number;
+    /** ISO-8601 date string (JSON-safe) */
+    mtime: string;
+    metadata: TMeta;
+}
+/**
+ * Flat list of file entries.
+ * Directories are inferred from file paths at runtime.
+ */
+type VirtualFileTree<TMeta = FileEntryMetadata> = FileEntry<TMeta>[];
+type TreeMutation<TMeta = FileEntryMetadata> = {
+    type: "add";
+    entry: FileEntry<TMeta>;
+} | {
+    type: "remove";
+    path: string;
+} | {
+    type: "update";
+    path: string;
+    entry: Partial<FileEntry<TMeta>>;
+};
+/**
+ * Consumer-provided bridge to the existing DB / S3 / CRUD layer.
+ *
+ * Generic over `TCtx` so every call receives workflow-level context
+ * (e.g. `{ projectId: string }`) without the resolver holding state.
+ *
+ * Generic over `TMeta` so resolved entries carry typed metadata.
+ */
+interface FileResolver<TCtx = unknown, TMeta = FileEntryMetadata> {
+    resolveEntries(ctx: TCtx): Promise<FileEntry<TMeta>[]>;
+    readFile(id: string, ctx: TCtx): Promise<string>;
+    readFileBuffer(id: string, ctx: TCtx): Promise<Uint8Array>;
+    writeFile(id: string, content: string | Uint8Array, ctx: TCtx): Promise<void>;
+    createFile(path: string, content: string | Uint8Array, ctx: TCtx): Promise<FileEntry<TMeta>>;
+    deleteFile(id: string, ctx: TCtx): Promise<void>;
+}
+/**
+ * Options for {@link VirtualSandboxProvider.create}.
+ * Extends base options with resolver context.
+ */
+interface VirtualSandboxCreateOptions<TCtx> extends SandboxCreateOptions {
+    resolverContext: TCtx;
+}
+/**
+ * The portion of workflow `AgentState` that the virtual sandbox reads via
+ * {@link queryParentWorkflowState}. Populated automatically by the session
+ * from the provider's `stateUpdate` after `createSandbox`.
+ */
+interface VirtualSandboxState<TCtx = unknown, TMeta = FileEntryMetadata> {
+    sandboxId: string;
+    fileTree: FileEntry<TMeta>[];
+    resolverContext: TCtx;
+}
+/**
+ * A {@link Sandbox} whose filesystem is backed by a {@link VirtualSandboxFileSystem}.
+ */
+type VirtualSandbox<TCtx = unknown, TMeta = FileEntryMetadata> = Sandbox & {
+    fs: VirtualSandboxFileSystem<TCtx, TMeta>;
+};
+/**
+ * Extended router context injected by {@link withVirtualSandbox}.
+ * Guarantees a live (ephemeral) sandbox built from the workflow file tree.
+ */
+interface VirtualSandboxContext<TCtx = unknown, TMeta = FileEntryMetadata> extends RouterContext {
+    sandbox: VirtualSandbox<TCtx, TMeta>;
+}
+
+export { type FileEntryMetadata as F, type TreeMutation as T, type VirtualSandboxCreateOptions as V, type FileResolver as a, type VirtualSandboxContext as b, type FileEntry as c, type VirtualSandbox as d, type VirtualFileTree as e, VirtualSandboxFileSystem as f, type VirtualSandboxState as g };