@artinet/sdk 0.6.0-preview.3 → 0.6.0

package/dist/config/index.d.ts

@@ -153,6 +153,6 @@ export declare const logger: {
     warn: (msg: string, ...args: unknown[]) => void;
     error: (msg: string, err: unknown) => void;
     setLevel: (level: "debug" | "info" | "warn" | "error") => void | undefined;
-    getLevel: () => "silent" | "error" | "debug" | "info" | "trace" | "verbose" | "warn";
+    getLevel: () => "error" | "trace" | "verbose" | "debug" | "info" | "warn" | "silent";
     child: (context: Record<string, unknown>) => ILogger;
 };

package/dist/config/observability.d.ts

@@ -2,7 +2,7 @@
  * Copyright 2025 The Artinet Project
  * SPDX-License-Identifier: Apache-2.0
  */
-/** //todo move to @artinet/sdk from core v0.1
+/**
  * @fileoverview Zero-dependency observability interfaces for the Artinet ecosystem.
  *
  * Provides minimal interfaces for logging and tracing that consumers can implement

package/dist/create/agent-builder.d.ts

@@ -51,7 +51,7 @@ export type Resolved<Ret extends AcceptedReturnValues = A2A.TextPart["text"], In
     handler: Transform<Ret>;
 };
 export type inferCarry<Carried> = Carried extends ReturnAndCarry<any, infer Carry> ? Carry : EmptyArgs;
-export type inC<Carried> = Carried extends ReturnAndCarry<any, infer Carry> ? Carry : EmptyArgs;
+export type inC<C> = inferCarry<C>;
 export interface AgentBuilder<Input extends BaseArgs = EmptyArgs> {
     /**
      * Add a step to the builder.

package/dist/create/create.d.ts

@@ -36,11 +36,13 @@ import { A2A } from "../types/index.js";
 import * as A from "./agent-builder.js";
 import { ServiceParams } from "../services/a2a/factory/service.js";
 import { describe } from "./index.js";
-import { ServerParams } from "../server/index.js";
 import { Service } from "../services/a2a/service.js";
 import { MessageParams } from "./message-builder.js";
 import { StatusUpdateParams, ArtifactUpdateParams, TaskParams } from "./task-builder.js";
-import { A2AClient } from "../client/a2a-client.js";
+import { ServerParams } from "../server/express/server.js";
+export interface MessageSender {
+    sendMessage(params: A2A.MessageSendParams): Promise<A2A.SendMessageSuccessResult>;
+}
 /**
  * Type alias for text-based workflow steps.
  *
@@ -404,7 +406,7 @@ export declare class AgentFactory<I extends A.bargs = A.empty> implements A.Agen
         agent: Service;
         start: (_port?: number) => import("node:http").Server<typeof import("node:http").IncomingMessage, typeof import("node:http").ServerResponse>;
     };
-    addStep<Ret extends A.AcceptedReturnValues = A.text, C extends A.bargs = A.empty, R extends A.rep<Ret, C> = A.rep<Ret, C>, Kind extends A.AcceptedKinds = "text">(step: A.Resolved<Ret, I, C, R, Kind>): AgentFactory<A.inC<R>>;
+    addStep<Ret extends A.AcceptedReturnValues = A.text, C extends A.bargs = A.empty, R extends A.rep<Ret, C> = A.rep<Ret, C>, Kind extends A.AcceptedKinds = "text">(step: A.Resolved<Ret, I, C, R, Kind>): AgentFactory<A.inferCarry<R>>;
     /**
      * Adds a text processing step to the workflow.
      *
@@ -617,16 +619,17 @@ export declare class AgentFactory<I extends A.bargs = A.empty> implements A.Agen
     /**
      * Adds an agent-to-agent orchestration step to the workflow.
      *
-     * This step sends a message to another agent (local Service or remote A2AClient)
+     * This step sends a message to another agent (local Service or remote A2A Server)
      * and yields the response as a task. Enables multi-agent workflows where one
      * agent delegates work to others.
      *
      * **Note:** This is currently a blocking call. Streaming responses are not
      * yet supported in orchestration steps.
+     * @note Args passed from the previous step are inserted, by default,
+     *  (`unshift`) as `DataPart`s onto the forwarded `Message`.`Parts`.
      *
-     * @param agent_and_message - Configuration object with target agent and optional message
-     * @param agent_and_message.agent - The target agent (Service or A2AClient)
-     * @param agent_and_message.message - Message to send (defaults to context.userMessage)
+     * @param agent - The target agent (Agent or AgentMessenger)
+     * @param message - Message to send (defaults to context.userMessage)
      * @returns New builder instance with task carry args (args.task)
      *
      * @example
@@ -655,7 +658,7 @@ export declare class AgentFactory<I extends A.bargs = A.empty> implements A.Agen
     sendMessage<Carry extends A.BaseArgs = {
         task?: A2A.Task;
     }>(agent_and_message: {
-        agent: Service | A2AClient;
+        agent: MessageSender;
         message?: A.sMessage | string;
     }): AgentFactory<A.inferCarry<A.Reply<A.Stateless<TaskParams>, Carry>>>;
     /**
@@ -669,15 +672,7 @@ export declare class AgentFactory<I extends A.bargs = A.empty> implements A.Agen
      * const factory = AgentFactory.create(myCard, { params });
      * ```
      */
-    static create<Input extends A.bargs = A.empty>(agentCard: describe.AgentCardParams, params?: FactoryParams): AgentFactory<Input>;
-    /**
-     * @deprecated Use engine instead
-     */
-    createAgentEngine(): A2A.Engine;
-    /**
-     * @deprecated Use {@link agent} instead
-     */
-    createAgent(params: Omit<ServiceParams, "engine">): Service;
+    static create(agentCard: describe.AgentCardParams, params?: FactoryParams): AgentFactory<A.EmptyArgs>;
 }
 /**
  * Creates a new AgentFactory instance for building agent workflows.
@@ -717,11 +712,15 @@ export declare class AgentFactory<I extends A.bargs = A.empty> implements A.Agen
  * @since 0.6.0
  */
 export declare const cr8: typeof AgentFactory.create;
-export declare const test: A.Resolved<any, any, any, any, any>[];
 /**
- * @deprecated Use cr8 instead
+ * @deprecated Use {@link cr8} instead
+ * @note This export exists only to alert users that `AgentBuilder` is deprecated.
+ * `AgentBuilder` no longer comes with the `createAgent` method.
+ * @since 0.6.0
  */
-export declare const AgentBuilder: typeof AgentFactory;
+export declare class AgentBuilder extends AgentFactory {
+    constructor(agentCard?: describe.AgentCardParams | string, params?: FactoryParams);
+}
 /**
  * Creates an agent execution engine from a list of workflow steps.
  *

package/dist/create/create.js

@@ -37,10 +37,10 @@ import * as transform from "./transform.js";
 import { createAgent as createAgentImpl, } from "../services/a2a/factory/service.js";
 import { describe } from "./index.js";
 import { extractTextContent } from "../services/a2a/helpers/content.js";
-import { createAgentServer } from "../server/index.js";
 import { logger } from "../config/index.js";
 import { v4 as uuidv4 } from "uuid";
 import { formatJson } from "../utils/index.js";
+import { serve } from "../server/express/server.js";
 const toFunction = (function_or_ret) => {
     return typeof function_or_ret === "function"
         ? function_or_ret
@@ -170,7 +170,7 @@ export class AgentFactory {
         });
     }
     get server() {
-        return createAgentServer({
+        return serve({
             agent: this.agent,
             ...this._params,
         });
@@ -183,7 +183,7 @@ export class AgentFactory {
         });
     }
     serve(engine = this.engine) {
-        return createAgentServer({
+        return serve({
             agent: this.from(engine),
             ...this._params,
         });
@@ -199,7 +199,7 @@ export class AgentFactory {
         return this.addStep({
             id: uuidv4(),
             step: stepFn,
-            kind: "text",
+            kind: A2A.Kind["text"],
             handler: transform.Parts("text"),
         });
     }
@@ -208,7 +208,7 @@ export class AgentFactory {
         return this.addStep({
             id: uuidv4(),
             step: stepFn,
-            kind: "file",
+            kind: A2A.Kind["file"],
             handler: transform.Parts("file"),
         });
     }
@@ -217,7 +217,7 @@ export class AgentFactory {
         return this.addStep({
             id: uuidv4(),
             step: stepFn,
-            kind: "data",
+            kind: A2A.Kind["data"],
             handler: transform.Parts("data"),
         });
     }
@@ -226,7 +226,7 @@ export class AgentFactory {
         return this.addStep({
             id: uuidv4(),
             step: stepFn,
-            kind: "message",
+            kind: A2A.Kind["message"],
             handler: transform.Message(),
         });
     }
@@ -235,7 +235,7 @@ export class AgentFactory {
         return this.addStep({
             id: uuidv4(),
             step: stepFn,
-            kind: "artifact-update",
+            kind: A2A.Kind["artifact-update"],
             handler: transform.Artifact(),
         });
     }
@@ -244,7 +244,7 @@ export class AgentFactory {
         return this.addStep({
             id: uuidv4(),
             step: stepFn,
-            kind: "status-update",
+            kind: A2A.Kind["status-update"],
             handler: transform.Status(),
         });
     }
@@ -260,16 +260,17 @@ export class AgentFactory {
     /**
      * Adds an agent-to-agent orchestration step to the workflow.
      *
-     * This step sends a message to another agent (local Service or remote A2AClient)
+     * This step sends a message to another agent (local Service or remote A2A Server)
      * and yields the response as a task. Enables multi-agent workflows where one
      * agent delegates work to others.
      *
      * **Note:** This is currently a blocking call. Streaming responses are not
      * yet supported in orchestration steps.
+     * @note Args passed from the previous step are inserted, by default,
+     *  (`unshift`) as `DataPart`s onto the forwarded `Message`.`Parts`.
      *
-     * @param agent_and_message - Configuration object with target agent and optional message
-     * @param agent_and_message.agent - The target agent (Service or A2AClient)
-     * @param agent_and_message.message - Message to send (defaults to context.userMessage)
+     * @param agent - The target agent (Agent or AgentMessenger)
+     * @param message - Message to send (defaults to context.userMessage)
      * @returns New builder instance with task carry args (args.task)
      *
      * @example
@@ -296,12 +297,16 @@ export class AgentFactory {
      * ```
      */
     sendMessage(agent_and_message) {
-        const stepFn = async ({ context }) => {
+        const stepFn = async ({ context, args }) => {
             logger.info("sendMessage: Sending message: ", {
                 agent: agent_and_message.agent.constructor.name,
             });
+            const messageSendParams = describe.messageSendParams(agent_and_message.message ?? context.userMessage);
+            if (args) {
+                messageSendParams.message.parts.unshift(describe.part.data({ ...args }));
+            }
             const response = await agent_and_message.agent
-                .sendMessage(describe.messageSendParams(agent_and_message.message ?? context.userMessage))
+                .sendMessage(messageSendParams)
                 .catch((error) => {
                 logger.error("sendMessage: Error sending message: ", error);
                 return null;
@@ -350,21 +355,6 @@ export class AgentFactory {
     static create(agentCard, params) {
         return new AgentFactory(describe.card(agentCard), params);
     }
-    /**
-     * @deprecated Use engine instead
-     */
-    createAgentEngine() {
-        return createStepEngine(this.steps);
-    }
-    /**
-     * @deprecated Use {@link agent} instead
-     */
-    createAgent(params) {
-        return createAgentImpl({
-            ...params,
-            engine: this.createAgentEngine(),
-        });
-    }
 }
 /**
  * Creates a new AgentFactory instance for building agent workflows.
@@ -403,73 +393,18 @@ export class AgentFactory {
  * @public
  * @since 0.6.0
  */
-export const cr8 = AgentFactory.create.bind(AgentFactory);
-const testAgent = cr8("TestAgent").text("Hello there!").agent;
-export const test = cr8("TestAgent")
-    .text("Hello there!")
-    .text(({ message }) => {
-    const jackfruit = `${message.message.role} there`;
-    return {
-        reply: ["hello there"],
-        args: {
-            jackfruit: jackfruit,
-        },
-    };
-})
-    .task(({ context, args }) => {
-    console.log(context);
-    return args?.jackfruit ?? "no jackfruit";
-})
-    .sendMessage({ agent: testAgent, message: "Hello there!" })
-    .text(({ args }) => {
-    return args?.task?.status.state ?? "no task";
-})
-    .message("Hello there!")
-    .artifact(({ context }) => {
-    return describe.artifact({
-        artifactId: context.taskId,
-        parts: [{ kind: "text", text: "Hello there!" }],
-    });
-})
-    .message(({ context }) => {
-    return context.taskId;
-})
-    .message(({ context }) => {
-    return describe.message({
-        role: "agent",
-        contextId: context.contextId,
-        parts: [{ kind: "text", text: "Hello there!" }],
-    });
-})
-    .text(({ args }) => {
-    return [`Hello ${args?.jackfruit}!`];
-})
-    .status("working")
-    .status(() => {
-    return {
-        status: {
-            state: A2A.TaskState.completed,
-        },
-    };
-})
-    .text(({ context }) => {
-    return [`Hello!`, context.taskId];
-})
-    .status(({ context }) => {
-    return {
-        status: {
-            contextId: context.contextId,
-            state: A2A.TaskState.completed,
-        },
-    };
-})
-    .task(({ context }) => {
-    return context.taskId;
-}).steps;
+export const cr8 = AgentFactory.create;
 /**
- * @deprecated Use cr8 instead
+ * @deprecated Use {@link cr8} instead
+ * @note This export exists only to alert users that `AgentBuilder` is deprecated.
+ * `AgentBuilder` no longer comes with the `createAgent` method.
+ * @since 0.6.0
  */
-export const AgentBuilder = AgentFactory;
+export class AgentBuilder extends AgentFactory {
+    constructor(agentCard = "default", params) {
+        super(describe.card(typeof agentCard === "string" ? { name: agentCard } : agentCard), params);
+    }
+}
 /**
  * Creates an agent execution engine from a list of workflow steps.
  *
@@ -531,12 +466,10 @@ export function createStepEngine(stepsList) {
         });
         logger.debug(`engine[context:${context.contextId}]: submitted`);
         yield submitted;
-        // let finalState: A2A.TaskState = A2A.TaskState.completed;
         for (const step of stepsList) {
-            // if (await context.isCancelled()) {
-            //   finalState = A2A.TaskState.canceled;
-            //   break;
-            // }
+            if (await context.isCancelled()) {
+                break;
+            }
             logger.debug(`engine[context:${context.contextId}]: executing step[${step.id}]: ${step.kind}`);
             const ret = await step.step({ ...input });
             if (_skipStep) {
@@ -550,7 +483,6 @@ export function createStepEngine(stepsList) {
         }
         const task = await context.getTask();
         logger.debug(`engine[context:${context.contextId}]: completed task[${task.id}]: ${formatJson(task)}`);
-        // task.status.state = finalState;
         yield task;
     };
 }

package/dist/create/message-builder.d.ts

@@ -54,7 +54,7 @@ export type MessageSendParamsParams = Partial<Kindless<A2A.MessageSendParams>> |
  * @returns New {@link A2A.MessageSendParams} with default parameters
  * @defaults {
  *   message: {
- *     role: "agent",
+ *     role: "user",
  *     parts: [],
  *     messageId: uuidv4(),
  *     kind: "message",

package/dist/create/message-builder.js

@@ -8,8 +8,6 @@ export class Message {
     _message;
     constructor(params = {}) {
         const messageId = params.messageId ?? uuidv4();
-        // TODO: Consider whether default role should be "user" when used in messageSendParams context.
-        // Currently defaults to "agent" which may be incorrect for MessageSendParams.
         this._message = {
             ...params,
             role: params.role ?? "agent",
@@ -79,7 +77,7 @@ export const MessageSendConfigurationBuilder = MessageSendConfiguration;
  * @returns New {@link A2A.MessageSendParams} with default parameters
  * @defaults {
  *   message: {
- *     role: "agent",
+ *     role: "user",
  *     parts: [],
  *     messageId: uuidv4(),
  *     kind: "message",
@@ -96,11 +94,25 @@ export const MessageSendConfigurationBuilder = MessageSendConfiguration;
  * @since 0.6.0
  */
 export function messageSendParams(params) {
-    const _isMessageParams = isMessageParams(params);
+    if (!isMessageParams(params)) {
+        return {
+            message: message(params.message),
+            configuration: new MessageSendConfiguration(params.configuration)
+                .configuration,
+            metadata: params.metadata,
+        };
+    }
+    if (typeof params === "string") {
+        return {
+            message: message({
+                role: "user",
+                parts: [{ text: params, kind: "text" }],
+            }),
+        };
+    }
+    params.role = params.role ?? "user";
     return {
-        message: message(_isMessageParams ? params : params.message),
-        configuration: new MessageSendConfiguration(_isMessageParams ? undefined : params.configuration).configuration,
-        metadata: _isMessageParams ? undefined : params.metadata,
+        message: message(params),
     };
 }
 /**

package/dist/create/task-builder.js

@@ -4,7 +4,7 @@
  */
 import { A2A } from "../types/index.js";
 import { v4 as uuidv4 } from "uuid";
-import { getCurrentTimestamp } from "../utils/common/utils.js";
+import { getCurrentTimestamp } from "../utils/utils.js";
 import { isMessageParams, Message,
 // type BuilderMessageParams,
  } from "./message-builder.js";

package/dist/index.d.ts

@@ -1,10 +1,10 @@
 export * from "./types/index.js";
-export * from "./client/index.js";
+export * from "./messenger/index.js";
 export * from "./server/index.js";
 export * from "./services/index.js";
-export * from "./transport/index.js";
-export * from "./utils/index.js";
+export * from "./storage/index.js";
 export * from "./config/index.js";
 export * from "./config/default.js";
 export * from "./create/create.js";
 export * from "./create/index.js";
+export * from "./utils/index.js";

package/dist/index.js

@@ -1,10 +1,10 @@
 export * from "./types/index.js";
-export * from "./client/index.js";
+export * from "./messenger/index.js";
 export * from "./server/index.js";
 export * from "./services/index.js";
-export * from "./transport/index.js";
-export * from "./utils/index.js";
+export * from "./storage/index.js";
 export * from "./config/index.js";
 export * from "./config/default.js";
 export * from "./create/create.js";
 export * from "./create/index.js";
+export * from "./utils/index.js";

package/dist/messenger/index.d.ts

@@ -0,0 +1 @@
+export { createMessenger, A2AClient, AgentMessenger, type MessengerParams, } from "./messenger.js";

package/dist/messenger/index.js

@@ -0,0 +1 @@
+export { createMessenger, A2AClient, AgentMessenger, } from "./messenger.js";

package/dist/messenger/messenger.d.ts

@@ -0,0 +1,119 @@
+/**
+ * Copyright 2025 The Artinet Project
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { A2A } from "../types/index.js";
+import * as describe from "../create/describe.js";
+import { ClientFactoryOptions, ClientConfig, Client, Transport, RequestOptions } from "@a2a-js/sdk/client";
+export interface MessengerParams {
+    baseUrl: URL | string;
+    headers?: Record<string, string>;
+    fallbackPath?: string;
+    factory?: ClientFactoryOptions;
+    config?: ClientConfig;
+}
+/**
+ * Messenger is the main communication client for interacting with remote A2A-compatible services.
+ * It provides methods for sending messages, retrieving tasks, canceling operations, and handling streaming responses.
+ */
+declare class Messenger implements Omit<Transport, "getAuthenticatedExtendedAgentCard" | "getExtendedAgentCard"> {
+    private _headers;
+    private _fallbackPath?;
+    private _baseUrl;
+    private _factory;
+    private clientPromise;
+    constructor(baseUrl: URL | string, _headers?: Record<string, string>, _fallbackPath?: string | undefined, factory?: ClientFactoryOptions, config?: ClientConfig);
+    reset(baseUrl?: URL | string, fallbackPath?: string | undefined): Promise<Client>;
+    get baseUrl(): string;
+    get headers(): Record<string, string>;
+    set headers(headers: Record<string, string>);
+    protected get _client(): Promise<Client>;
+    /**
+     * Retrieves the AgentCard from the A2A server.
+     * @returns A promise resolving to the AgentCard.
+     */
+    getAgentCard(requestOptions?: RequestOptions): Promise<A2A.AgentCard>;
+    sendMessage(params: A2A.MessageSendParams, options?: RequestOptions): Promise<A2A.SendMessageSuccessResult>;
+    sendMessage(params: describe.MessageParams, options?: RequestOptions): Promise<A2A.SendMessageSuccessResult>;
+    sendMessage(params: describe.MessageSendParamsParams, options?: RequestOptions): Promise<A2A.SendMessageSuccessResult>;
+    sendMessageStream(params: A2A.MessageSendParams, options?: RequestOptions): AsyncGenerator<A2A.Update, void, undefined>;
+    sendMessageStream(params: describe.MessageSendParamsParams, options?: RequestOptions): AsyncGenerator<A2A.Update, void, undefined>;
+    sendMessageStream(params: describe.MessageParams, options?: RequestOptions): AsyncGenerator<A2A.Update, void, undefined>;
+    /**
+     * Retrieves the current state of a task.
+     * @param params The parameters for the tasks/get method.
+     * @returns A promise resolving to the Task object or null.
+     */
+    getTask(params: A2A.TaskQueryParams, options?: RequestOptions): Promise<A2A.Task>;
+    /**
+     * Cancels a currently running task.
+     * @param params The parameters for the tasks/cancel method.
+     * @returns A promise resolving to the updated Task object (usually canceled state) or null.
+     */
+    cancelTask(params: A2A.TaskIdParams, options?: RequestOptions): Promise<A2A.Task>;
+    /**
+     * Sets or updates the push notification config for a task.
+     * @param params The parameters for the tasks/pushNotificationConfig/set method (which is TaskPushNotificationConfig).
+     * @returns A promise resolving to the confirmed TaskPushNotificationConfig or null.
+     */
+    setTaskPushNotificationConfig(params: A2A.TaskPushNotificationConfig, options?: RequestOptions): Promise<A2A.TaskPushNotificationConfig>;
+    /**
+     * Retrieves the currently configured push notification config for a task.
+     * @param params The parameters for the tasks/pushNotificationConfig/get method.
+     * @returns A promise resolving to the TaskPushNotificationConfig or null.
+     */
+    getTaskPushNotificationConfig(params: A2A.TaskIdParams, options?: RequestOptions): Promise<A2A.TaskPushNotificationConfig>;
+    listTaskPushNotificationConfig(params: A2A.ListTaskPushNotificationConfigParams, options?: RequestOptions): Promise<A2A.ListTaskPushNotificationConfigResult>;
+    deleteTaskPushNotificationConfig(params: A2A.DeleteTaskPushNotificationConfigParams, options?: RequestOptions): Promise<void>;
+    /**
+     * Resubscribes to an existing task's update stream.
+     * @param params Parameters identifying the task to resubscribe to
+     * @returns An AsyncIterable that yields TaskStatusUpdateEvent or TaskArtifactUpdateEvent payloads.
+     */
+    resubscribeTask(params: A2A.TaskQueryParams, options?: RequestOptions): AsyncGenerator<A2A.Update>;
+    /**
+     * Checks if the server supports a specific capability based on the agent card.
+     * @param capability The capability to check (e.g., 'streaming', 'pushNotifications').
+     * @returns A promise resolving to true if the capability is supported.
+     */
+    supports(capability: "streaming" | "pushNotifications" | "stateTransitionHistory" | "extentions"): Promise<boolean>;
+    /**
+     * Adds a single header to be included in all requests.
+     * @param name The header name.
+     * @param value The header value.
+     */
+    addHeader(name: string, value: string): void;
+    /**
+     * Removes a header.
+     * @param name The header name to remove.
+     */
+    removeHeader(name: string): void;
+    static create({ baseUrl, headers, fallbackPath, factory, config, }: MessengerParams): Promise<Messenger>;
+}
+/**
+ * Creates a new Messenger instance.
+ * @param baseUrl The base URL for the A2A server.
+ * @param headers Optional custom headers to include in all requests.
+ * @param fallbackPath Optional fallback path to use if the agent card is not found at the base URL.
+ * @example
+ * const messenger = createMessenger({
+ *   baseUrl: "http://localhost:4000/a2a",
+ * });
+ * const card = await messenger.getAgentCard();
+ * console.log(card);
+ * @example
+ * const messenger = createMessenger({
+ *   baseUrl: "http://localhost:4000/a2a",
+ *   fallbackPath: "/agent-card",
+ * });
+ * const card = await messenger.getAgentCard();
+ * console.log(card);
+ */
+export declare const createMessenger: typeof Messenger.create;
+export declare const AgentMessenger: typeof Messenger;
+export type AgentMessenger = Messenger;
+/**
+ * @deprecated Use {@link createMessenger} instead.
+ */
+export declare const A2AClient: typeof Messenger;
+export {};