runwork 0.2.0

package/bundled-types/core-workspace.d.ts

@@ -0,0 +1,454 @@
+/**
+ * Core Workspace Context
+ * DO NOT MODIFY THIS FILE - You may break the workspace functionality
+ *
+ * This module provides cross-app data sharing and workspace registration.
+ * Apps in the same workspace can query each other's entities and register
+ * their capabilities (entities, components, endpoints, etc.).
+ */
+import type { Env } from './core-utils';
+/**
+ * WorkspaceUser - Represents a member of the workspace
+ * Read-only data provided by the platform
+ */
+export interface WorkspaceUser {
+    id: string;
+    email: string;
+    name: string;
+    role: 'owner' | 'admin' | 'editor' | 'viewer';
+    avatarUrl: string | null;
+    joinedAt: number;
+}
+export interface ListUsersOptions {
+    limit?: number;
+    cursor?: string | null;
+}
+export interface ListUsersResponse {
+    items: WorkspaceUser[];
+    next: string | null;
+}
+/**
+ * Parameters for sending a notification to a workspace user
+ * The platform wraps your content in a standard notification template
+ */
+export interface NotifyUserParams {
+    /** User ID of the recipient (must be a workspace member) */
+    userId: string;
+    /** Notification title/subject */
+    title: string;
+    /** Plain text content (required) */
+    content: string;
+    /** Optional HTML content for rich formatting */
+    html?: string;
+}
+/**
+ * Result of sending a notification
+ */
+export interface NotifyUserResult {
+    success: boolean;
+    notificationId?: string;
+    error?: string;
+}
+export interface ListEntityRequest extends Record<string, unknown> {
+    entityName: string;
+    filters?: Record<string, unknown>;
+    limit?: number;
+    cursor?: string | null;
+    deploymentMode?: 'preview' | 'production';
+}
+export interface ListEntityResponse<T = unknown> {
+    items: T[];
+    next: string | null;
+}
+export interface GetEntityRequest extends Record<string, unknown> {
+    entityName: string;
+    id: string;
+    deploymentMode?: 'preview' | 'production';
+}
+export interface CreateEntityRequest extends Record<string, unknown> {
+    entityName: string;
+    data: Record<string, unknown>;
+    deploymentMode?: 'preview' | 'production';
+}
+export interface UpdateEntityRequest extends Record<string, unknown> {
+    entityName: string;
+    id: string;
+    data: Record<string, unknown>;
+    deploymentMode?: 'preview' | 'production';
+}
+export interface DeleteEntityRequest extends Record<string, unknown> {
+    entityName: string;
+    id: string;
+    deploymentMode?: 'preview' | 'production';
+}
+export interface RegisterEntityRequest extends Record<string, unknown> {
+    appId: string;
+    appName: string;
+    entityName: string;
+    schema?: Record<string, unknown>;
+    deploymentMode?: 'preview' | 'production';
+}
+export interface RegisterAppRequest extends Record<string, unknown> {
+    appId: string;
+    appName: string;
+}
+export interface RegisterComponentRequest extends Record<string, unknown> {
+    appId: string;
+    appName: string;
+    componentName: string;
+    metadata?: {
+        tag: string;
+        description?: string;
+        attributes?: Record<string, string>;
+    };
+    deploymentMode?: 'preview' | 'production';
+}
+export interface RegisterScheduleRequest extends Record<string, unknown> {
+    appId: string;
+    appName: string;
+    scheduleName: string;
+    schedule: string;
+    description?: string;
+    deploymentMode?: 'preview' | 'production';
+}
+export interface RegisterWorkflowRequest extends Record<string, unknown> {
+    appId: string;
+    appName: string;
+    workflowName: string;
+    description?: string;
+    enabled?: boolean;
+    deploymentMode?: 'preview' | 'production';
+}
+export interface RegisterEndpointRequest extends Record<string, unknown> {
+    appId: string;
+    appName: string;
+    path: string;
+    method: string;
+    authType: 'apiKey' | 'public';
+    name?: string;
+    description?: string;
+    tags?: string[];
+    schema?: {
+        query?: Record<string, unknown>;
+        body?: Record<string, unknown>;
+        response?: Record<string, unknown>;
+    };
+    version?: string;
+    deploymentMode?: 'preview' | 'production';
+}
+export interface RegisterIntegrationRequest extends Record<string, unknown> {
+    appId: string;
+    appName: string;
+    integrationId: string;
+    reason: string;
+    required: boolean;
+    deploymentMode?: 'preview' | 'production';
+}
+export interface RegisterAgentRequest extends Record<string, unknown> {
+    appId: string;
+    appName: string;
+    agentName: string;
+    description: string;
+    type: 'conversational' | 'task';
+    integrations: string[];
+    entities: string[];
+    deploymentMode?: 'preview' | 'production';
+}
+/**
+ * WorkspaceContext - Helper for cross-app data queries
+ * Provides methods to query entities from other apps in the same workspace
+ */
+export declare class WorkspaceContext {
+    private env;
+    private workspaceId;
+    private appId;
+    private appName;
+    private deploymentMode;
+    constructor(env: Env, workspaceId: string, appId: string, appName: string);
+    private canUseHttpFallback;
+    private getWorkspaceStub;
+    private fetchViaDurableObject;
+    private fetchViaHttp;
+    private workspaceFetch;
+    /**
+     * List entities from another app in the workspace with optional filters
+     */
+    list<T = unknown>(entityName: string, options?: {
+        filters?: Record<string, unknown>;
+        limit?: number;
+        cursor?: string | null;
+    }): Promise<ListEntityResponse<T>>;
+    /**
+     * Get a single entity by ID from another app in the workspace
+     */
+    get<T = unknown>(entityName: string, id: string): Promise<T | null>;
+    /**
+     * Create an entity in another app in the workspace
+     */
+    create<T = unknown>(entityName: string, data: Partial<T>): Promise<T>;
+    /**
+     * Update an entity in another app in the workspace
+     */
+    update<T = unknown>(entityName: string, id: string, data: Partial<T>): Promise<T>;
+    /**
+     * Delete an entity in another app in the workspace
+     */
+    deleteEntity(entityName: string, id: string): Promise<void>;
+    /**
+     * Register an entity with the workspace so other apps can query it
+     */
+    registerEntity(entityName: string, schema?: Record<string, unknown>): Promise<void>;
+    /**
+     * Register this app with the workspace (safe to call multiple times)
+     */
+    registerApp(): Promise<void>;
+    /**
+     * Register a component with the workspace so it can be discovered by other apps
+     */
+    registerComponent(componentName: string, metadata?: {
+        tag: string;
+        description?: string;
+        attributes?: Record<string, string>;
+    }): Promise<void>;
+    /**
+     * Register a scheduled job with the workspace for visibility
+     */
+    registerSchedule(scheduleName: string, config: {
+        schedule: string;
+        description?: string;
+    }): Promise<void>;
+    /**
+     * Register a workflow with the workspace for visibility and provisioning
+     */
+    registerWorkflow(workflowName: string, config: {
+        description?: string;
+        enabled?: boolean;
+    }): Promise<void>;
+    /**
+     * Register a public endpoint with the workspace for external access
+     */
+    registerEndpoint(path: string, config: {
+        method: string;
+        authType: 'apiKey' | 'public';
+        name?: string;
+        description?: string;
+        tags?: string[];
+        schema?: {
+            query?: Record<string, unknown>;
+            body?: Record<string, unknown>;
+            response?: Record<string, unknown>;
+        };
+        version?: string;
+    }): Promise<void>;
+    /**
+     * Register an integration requirement with the workspace
+     */
+    registerIntegration(integrationId: string, config: {
+        reason?: string;
+        required?: boolean;
+    }): Promise<void>;
+    /**
+     * Register an AI agent with the workspace for visibility
+     */
+    registerAgent(agentName: string, config: {
+        description: string;
+        type: 'conversational' | 'task';
+        integrations: string[];
+        entities: string[];
+    }): Promise<void>;
+    /**
+     * Register all scheduled jobs, removing any stale entries not in the list.
+     * This ensures schedules deleted from code are removed from the registry.
+     */
+    registerAllSchedules(schedules: Array<{
+        name: string;
+        schedule: string;
+        description?: string;
+    }>): Promise<void>;
+    /**
+     * Register all workflows, removing any stale entries not in the list.
+     * This ensures workflows deleted from code are removed from the registry.
+     */
+    registerAllWorkflows(workflows: Array<{
+        name: string;
+        description?: string;
+        enabled?: boolean;
+    }>): Promise<void>;
+    /**
+     * Register all endpoints, removing any stale entries not in the list.
+     * This ensures endpoints deleted from code are removed from the registry.
+     */
+    registerAllEndpoints(endpoints: Array<{
+        path: string;
+        method: string;
+        auth: 'apiKey' | 'public';
+        description?: string;
+        tags?: string[];
+        schema?: {
+            query?: Record<string, unknown>;
+            body?: Record<string, unknown>;
+            response?: Record<string, unknown>;
+        };
+    }>): Promise<void>;
+    /**
+     * Register all integration requirements, removing any stale entries not in the list.
+     * This ensures integrations deleted from code are removed from the registry.
+     */
+    registerAllIntegrations(integrations: Array<{
+        integrationId: string;
+        reason: string;
+        required: boolean;
+    }>): Promise<void>;
+    /**
+     * Register all AI agents, removing any stale entries not in the list.
+     * This ensures agents deleted from code are removed from the registry.
+     */
+    registerAllAgents(agents: Array<{
+        name: string;
+        description: string;
+        type: 'conversational' | 'task';
+        integrations?: string[];
+        entities?: string[];
+    }>): Promise<void>;
+    /**
+     * Register all components, removing any stale entries not in the list.
+     * This ensures components deleted from code are removed from the registry.
+     */
+    registerAllComponents(components: Array<{
+        name: string;
+        metadata?: {
+            tag: string;
+            description?: string;
+            attributes?: Record<string, string>;
+        };
+    }>): Promise<void>;
+    /**
+     * Connect object storage (R2 bucket) to signal the bucket is "alive"
+     */
+    connectObjectStorage(): Promise<void>;
+    /**
+     * Check if this app has an R2 bucket configured
+     */
+    hasBucket(): boolean;
+    get id(): string;
+    /**
+     * List all users in this workspace
+     * Returns paginated list of workspace members
+     *
+     * @example
+     * ```typescript
+     * const workspace = getWorkspaceContext(env);
+     * const { items: users, next } = await workspace.listUsers();
+     * // users: WorkspaceUser[]
+     * ```
+     */
+    listUsers(options?: ListUsersOptions): Promise<ListUsersResponse>;
+    /**
+     * Get a specific user by ID
+     * Returns null if user is not found or not a workspace member
+     *
+     * @example
+     * ```typescript
+     * const workspace = getWorkspaceContext(env);
+     * const user = await workspace.getUser(userId);
+     * if (user) {
+     *   console.log(user.name, user.email);
+     * }
+     * ```
+     */
+    getUser(userId: string): Promise<WorkspaceUser | null>;
+    /**
+     * Send a notification to a workspace user
+     * Can only send to verified workspace members
+     * The platform wraps your content in a standard notification template
+     * (e.g., "You have a new notification from [App Name]")
+     *
+     * @example
+     * ```typescript
+     * const workspace = getWorkspaceContext(env);
+     * const result = await workspace.notifyUser({
+     *   userId: assigneeId,
+     *   title: 'Task assigned to you',
+     *   content: 'You have been assigned a new task.',
+     *   html: '<p>You have been assigned a new task.</p>',
+     * });
+     * if (!result.success) {
+     *   console.error('Failed to send notification:', result.error);
+     * }
+     * ```
+     */
+    notifyUser(params: NotifyUserParams): Promise<NotifyUserResult>;
+}
+/**
+ * Get workspace context for cross-app queries
+ * Returns null if app is not part of a workspace
+ */
+export declare function getWorkspaceContext(env: Env): WorkspaceContext | null;
+/**
+ * List entities from ANOTHER app in the workspace (cross-app queries ONLY)
+ *
+ * CRITICAL: This function is for cross-app data access ONLY. Use it to query entities
+ * that are defined in OTHER apps in the same workspace.
+ *
+ * DO NOT use this for local entities owned by this app. For local entities, use the
+ * Entity class methods directly (e.g., TodoEntity.list(ctx), UserEntity.list(ctx)).
+ *
+ * Filters are applied as equality matching on entity fields.
+ *
+ * @example
+ * // CORRECT: List contacts from a separate CRM app in the workspace
+ * const contacts = await listWorkspaceEntity<Contact>(env, 'Contact', {
+ *   filters: { isActive: true },
+ *   limit: 50
+ * });
+ *
+ * @example
+ * // WRONG: Don't use this for local entities!
+ * // const todos = await listWorkspaceEntity<Todo>(env, 'Todo', { limit: 50 });
+ * // CORRECT: Use Entity class for local data
+ * // const ctx = { env };
+ * // const todos = await TodoEntity.list(ctx, { limit: 50 });
+ */
+export declare function listWorkspaceEntity<T = unknown>(env: Env, entityName: string, options?: {
+    filters?: Record<string, unknown>;
+    limit?: number;
+    cursor?: string | null;
+}): Promise<ListEntityResponse<T>>;
+/**
+ * Get a single entity by ID from ANOTHER app in the workspace (cross-app ONLY)
+ *
+ * @example
+ * const contact = await getWorkspaceEntity<Contact>(env, 'Contact', 'contact-123');
+ */
+export declare function getWorkspaceEntity<T = unknown>(env: Env, entityName: string, id: string): Promise<T | null>;
+/**
+ * Create an entity in ANOTHER app in the workspace (cross-app ONLY)
+ *
+ * @example
+ * const newContact = await createWorkspaceEntity<Contact>(env, 'Contact', {
+ *   name: 'John Doe',
+ *   email: 'john@example.com'
+ * });
+ */
+export declare function createWorkspaceEntity<T = unknown>(env: Env, entityName: string, data: Partial<T>): Promise<T>;
+/**
+ * Update an entity in ANOTHER app in the workspace (cross-app ONLY)
+ *
+ * @example
+ * const updated = await updateWorkspaceEntity<Contact>(env, 'Contact', 'contact-123', {
+ *   status: 'inactive'
+ * });
+ */
+export declare function updateWorkspaceEntity<T = unknown>(env: Env, entityName: string, id: string, data: Partial<T>): Promise<T>;
+/**
+ * Delete an entity in ANOTHER app in the workspace (cross-app ONLY)
+ *
+ * @example
+ * await deleteWorkspaceEntity(env, 'Contact', 'contact-123');
+ */
+export declare function deleteWorkspaceEntity(env: Env, entityName: string, id: string): Promise<void>;
+/**
+ * Register all entities, components, and schedules with the workspace
+ * Called once when the worker starts
+ */
+export declare function initializeWorkspace(env: Env): Promise<void>;

package/bundled-types/create-app.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Application entry point for Runwork apps.
+ *
+ * Users call createApp() in their worker entry file to register their
+ * application code (agents, entities, routes, etc.) and get back
+ * a Cloudflare Workers ExportedHandler.
+ *
+ * @example
+ * ```typescript
+ * // worker/index.ts
+ * import { createApp } from '@runworkai/framework';
+ * import { APP_AGENTS } from './agents';
+ * import { APP_ENTITIES } from './entities';
+ * import { APP_ROUTES } from './routes';
+ *
+ * export default createApp({
+ *   agents: APP_AGENTS,
+ *   entities: APP_ENTITIES,
+ *   routes: APP_ROUTES,
+ * });
+ * ```
+ */
+import { type ComponentDefinition, type RouteEntry } from './app-registry';
+import type { AgentDefinition } from './core-agent';
+import type { EntityClass } from './core-entities';
+import type { EndpointDefinition } from './core-endpoints';
+import type { IntegrationRequirement } from './core-integrations';
+import type { ScheduledJob } from './core-scheduler';
+import type { Env } from './core-utils';
+import type { WorkflowDefinition } from './core-workflow-types';
+/**
+ * Options for createApp(). All fields are optional -- omitted fields
+ * default to empty arrays.
+ */
+export interface CreateAppOptions {
+    agents?: AgentDefinition[];
+    entities?: Array<EntityClass<{
+        id: string;
+    }>>;
+    routes?: RouteEntry[];
+    endpoints?: EndpointDefinition[];
+    workflows?: WorkflowDefinition[];
+    schedules?: ScheduledJob[];
+    integrationRequirements?: IntegrationRequirement[];
+    components?: ComponentDefinition[];
+}
+/**
+ * Initialize a Runwork application with the given feature registrations.
+ *
+ * Registers user-defined agents, entities, routes, and other features
+ * into the global app registry so framework core files can access them
+ * without direct imports.
+ *
+ * Returns an ExportedHandler suitable for use as the default export
+ * of a Cloudflare Worker entry point.
+ */
+export declare function createApp(options?: CreateAppOptions): ExportedHandler<Env>;

package/bundled-types/endpoints.d.ts

@@ -0,0 +1,2 @@
+export { isEndpointDefinition, jsonResponse, errorResponse, zodToJsonSchema, EndpointRouter, mountEndpointAsHonoRoute, handleEndpointRequest, EndpointError, endpointToRegistration, } from './core-endpoints';
+export type { EndpointAuthType, EndpointMethod, EndpointSchema, EndpointContext, EndpointAuthInfo, EndpointLogger, EndpointMeta, EndpointDefinition, EndpointHandler, ParsedEndpointRequest, } from './core-endpoints';

package/bundled-types/entities.d.ts

@@ -0,0 +1,5 @@
+export { entityRegistry, registerEntity, registerEntities, EntityBase, Entity, entityRoutes, } from './core-entities';
+export type { EntityDOStub, EntityContext, ListOptions, PaginatedResult, EntityClass, Doc, EntityStatics, } from './core-entities';
+export { EntityDO, SAFE_FIELD_NAME, QUERY_LIMITS, validateFieldName, escapeLikePattern } from './core-entity-do';
+export { IntegrationEntity, isIntegrationEntity } from './core-integration-entities';
+export type { OperationConfig, IntegrationEntityConfig, IntegrationEntityClass, } from './core-integration-entities';

package/bundled-types/events.d.ts

@@ -0,0 +1,2 @@
+export { emitEvent, toChannelName, flog } from './core-events';
+export type { EmitEventParams } from './core-events';

package/bundled-types/index.d.ts

@@ -0,0 +1,19 @@
+export { createApp } from './create-app';
+export type { CreateAppOptions } from './create-app';
+export type { AppConfig } from './app-registry';
+export { ok, bad, notFound, isStr, safeClone, platformFetch, workspaceApiFetch } from './core-utils';
+export type { Env } from './core-utils';
+export type { ApiResponse } from './shared/core-types';
+export * from './entities';
+export * from './routes';
+export * from './agents';
+export * from './ai';
+export * from './workflows';
+export * from './scheduler';
+export * from './endpoints';
+export * from './storage';
+export * from './integrations';
+export * from './channels';
+export * from './workspace';
+export * from './events';
+export * from './components';

package/bundled-types/integrations.d.ts

@@ -0,0 +1,2 @@
+export { IntegrationClient, createIntegrationClient, } from './core-integrations';
+export type { IntegrationRequirement, NangoActionResponse, NangoProxyOptions, } from './core-integrations';

package/bundled-types/routes.d.ts

@@ -0,0 +1,2 @@
+export { setupRoutes } from './core-routes';
+export type { ClientErrorReport } from './core-routes';

package/bundled-types/scheduler.d.ts

@@ -0,0 +1,2 @@
+export { parseCronExpression, calculateNextRun, SchedulerDO, initializeScheduler, schedulerRoutes, } from './core-scheduler';
+export type { ScheduledJob, JobContext, JobResult, JobLogger, JobRunRecord, ScheduleState, SchedulerRegistry, ScheduleStatusResponse, } from './core-scheduler';

package/bundled-types/storage.d.ts

@@ -0,0 +1,2 @@
+export { FileStorageClient, createFileStorageClient, fileStorageRoutes, } from './core-file-storage';
+export type { FileMetadata, UploadOptions, DownloadOptions, ListFilesOptions, ListFilesResult, PresignedUrlRequest, PresignedUrlResponse, } from './core-file-storage';

package/bundled-types/test-entry.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Test Entry Point
+ *
+ * Minimal entry point for vitest-pool-workers that exports only
+ * the DOs needed for testing, avoiding dependencies that don't work in
+ * the miniflare test environment (agents, ai SDK, MCP, etc.)
+ */
+export { EntityDO } from './core-entity-do';
+export { SchedulerDO } from './core-scheduler';
+export declare class BaseAgent {
+    state: DurableObjectState;
+    env: unknown;
+    constructor(state: DurableObjectState, env: unknown);
+    fetch(_request: Request): Promise<Response>;
+}
+export { WorkflowInstanceDO } from './core-workflow-instance';
+export { WorkflowCoordinator } from './core-workflow-coordinator';
+declare const _default: {
+    fetch(_request: Request): Promise<Response>;
+};
+export default _default;

package/bundled-types/types.d.ts

@@ -0,0 +1 @@
+export type { ApiResponse, NangoActionResponse, NangoProxyOptions, FileMetadata, UploadOptions, DownloadOptions, ListFilesOptions, ListFilesResult, PresignedUrlRequest, PresignedUrlResponse, } from './shared/core-types';

package/bundled-types/vite.d.ts

@@ -0,0 +1,23 @@
+import { defineConfig, type Plugin } from "vite";
+export interface RunworkPluginOptions {
+    /**
+     * Override the detected mode. By default, the plugin detects sandbox mode
+     * when DEPLOYMENT_MODE or WORKSPACE_ID environment variables are present.
+     */
+    mode?: "sandbox" | "local";
+    /**
+     * Root directory of the project. Defaults to process.cwd().
+     */
+    root?: string;
+    /**
+     * Path aliases to configure. Defaults to { "@": "./src", "@shared": "./shared" }.
+     */
+    aliases?: Record<string, string>;
+    /**
+     * Whether to use JSON logging (pino) in sandbox mode.
+     * Defaults to true when VITE_LOGGER_TYPE=json.
+     */
+    jsonLogger?: boolean;
+}
+export declare function runwork(options?: RunworkPluginOptions): ReturnType<typeof defineConfig>;
+export type { Plugin };

package/bundled-types/workflows.d.ts

@@ -0,0 +1,14 @@
+import type { WorkflowDefinition } from './core-workflow-types';
+/**
+ * APP_WORKFLOWS - runtime accessor for registered workflow definitions.
+ * Used by internal dynamic imports in core-workflow-cloudflare and core-workflow-instance.
+ * This is a getter-backed constant so it always reflects the current registry state.
+ */
+export declare const APP_WORKFLOWS: WorkflowDefinition[];
+export { triggerWorkflow, sendWorkflowEvent, getWorkflowStatus, workflowRoutes, } from './core-workflows';
+export type { WorkflowResult, WorkflowStatus, WorkflowInstanceInfo, WorkflowDefinition, WorkflowContext, WorkflowStepUtilities, StepOptions, WaitEventOptions, WorkflowLogger, WorkflowState, WorkflowStatusResponse, } from './core-workflows';
+export type { NativeWorkflowStatus, NativeStepStatus, NativeStepType, NativeWorkflowError, NativeStepAttempt, NativeStepExecution, NativeWorkflowInstance, NativeWorkflowConfig, NativeStepContext, WorkflowIndexEntry, ListWorkflowsOptions, ExecuteStepRequest, ExecuteStepResponse, PendingEvent, ReceivedEvent, WorkflowInstanceStub, WorkflowCoordinatorStub, } from './core-workflow-types';
+export { DEFAULT_WORKFLOW_CONFIG } from './core-workflow-types';
+export { WORKFLOW_INFRA_MODE } from './core-workflow-config';
+export { WorkflowInstanceDO } from './core-workflow-instance';
+export { WorkflowCoordinator } from './core-workflow-coordinator';

package/bundled-types/workspace.d.ts

@@ -0,0 +1,2 @@
+export { WorkspaceContext, getWorkspaceContext, listWorkspaceEntity, getWorkspaceEntity, createWorkspaceEntity, updateWorkspaceEntity, deleteWorkspaceEntity, initializeWorkspace, } from './core-workspace';
+export type { WorkspaceUser, ListUsersOptions, ListUsersResponse, NotifyUserParams, NotifyUserResult, ListEntityRequest, ListEntityResponse, GetEntityRequest, CreateEntityRequest, UpdateEntityRequest, DeleteEntityRequest, RegisterEntityRequest, RegisterAppRequest, RegisterComponentRequest, RegisterScheduleRequest, RegisterWorkflowRequest, RegisterEndpointRequest, RegisterIntegrationRequest, RegisterAgentRequest as WorkspaceRegisterAgentRequest, } from './core-workspace';

package/dist/__tests__/types-manager.test.d.ts

@@ -0,0 +1 @@
+export {};