qlogicagent 2.7.0 → 2.9.0

package/dist/types/llm/transports/gemini-media.d.ts

@@ -1,53 +0,0 @@
-/**
- * Gemini Media Transport — unified media generation for all Gemini media APIs.
- *
- * Supported media types and endpoints:
- *   image          — POST /models/{model}:generateContent  (responseModalities: ["TEXT","IMAGE"])
- *   video          — POST /models/{model}:predictLongRunning → poll operations → download URI
- *   music          — POST /models/{model}:generateContent  (Lyria 3 — inlineData audio)
- *   music_realtime — WebSocket session (Lyria RealTime — streaming PCM → WAV)
- *   tts            — POST /models/{model}:generateContent  (speechConfig — inlineData PCM)
- *   embedding      — POST /models/{model}:embedContent   (float vector)
- *
- * Auth: x-goog-api-key header for all endpoints.
- */
-import type { AsyncMediaTransport, MediaRequest, MediaResult, MediaType } from "../media-transport.js";
-export interface GeminiMediaConfig {
-    /** Base URL, e.g. "https://generativelanguage.googleapis.com/v1beta" */
-    baseUrl: string;
-    timeoutMs?: number;
-}
-export declare class GeminiMediaTransport implements AsyncMediaTransport {
-    readonly supportedTypes: readonly MediaType[];
-    private apiBase;
-    private timeoutMs;
-    constructor(config: GeminiMediaConfig);
-    generate(request: MediaRequest, apiKey: string, signal?: AbortSignal): Promise<MediaResult>;
-    deleteVideoTask(_taskId: string, _apiKey: string, _signal?: AbortSignal): Promise<void>;
-    listVideoTasks(_apiKey: string, _options?: {
-        after?: string;
-        limit?: number;
-        status?: string;
-    }, _signal?: AbortSignal): Promise<Record<string, unknown>>;
-    getTaskStatus(taskId: string, apiKey: string, signal?: AbortSignal): Promise<{
-        status: string;
-        task: Record<string, unknown>;
-    }>;
-    private generateImage;
-    private generateVideo;
-    private generateMusic;
-    private generateMusicRealtime;
-    private generateTTS;
-    private generateEmbedding;
-    private postJson;
-    private pollOperation;
-    /**
-     * Resolve an image URL to inline data for the Veo API.
-     * Supports file:// paths and https:// URLs.
-     */
-    private resolveImageData;
-    /** Extract base64 image data from generateContent response → persist to cache files. */
-    private extractInlineImages;
-    /** Extract base64 audio data from generateContent response → persist to cache files. */
-    private extractInlineAudio;
-}

package/dist/types/llm/transports/media-resolve.d.ts

@@ -1,50 +0,0 @@
-/**
- * Media URL Resolution — resolves local/private URLs for cloud LLM APIs.
- *
- * Cloud LLM APIs (OpenAI, Anthropic, DeepSeek, etc.) cannot fetch content
- * from localhost or private networks.
- *
- * **Primary approach (upload-based):**
- *   Local URLs are fetched → uploaded to provider's File API or Aliyun OSS → public URL returned.
- *   This is the ONLY approach for images, video, and documents.
- *
- * **Audio exception (base64):**
- *   OpenAI's input_audio.data API field mandates base64 encoding.
- *   resolveMediaUrl() is retained ONLY for this case.
- *
- * URL-first design: the gateway stores media as HTTP URLs; this layer handles
- * the last-mile transformation before sending to provider APIs.
- */
-import type { FileUploadAdapter } from "../file-upload-service.js";
-/** Check if a URL points to a local/private address that cloud APIs cannot reach. */
-export declare function isLocalUrl(url: string): boolean;
-export interface MediaResolveContext {
-    /** Provider-specific upload adapter. */
-    uploadAdapter: FileUploadAdapter;
-    /** API key for the upload. */
-    apiKey: string;
-    /** Abort signal. */
-    signal?: AbortSignal;
-}
-/**
- * Resolve a local URL by uploading to the provider's File API.
- * This is the **preferred** method for all media types.
- *
- * Public URLs pass through unchanged.
- * Local URLs are uploaded → public URL or file_id returned.
- */
-export declare function resolveMediaUrlViaUpload(url: string, ctx: MediaResolveContext): Promise<string>;
-/**
- * Batch-resolve URLs via upload. Best-effort: failures return original URL.
- */
-export declare function resolveMediaUrlsViaUpload(urls: string[], ctx: MediaResolveContext): Promise<string[]>;
-/**
- * Resolve local audio URL to base64 data URL.
- *
- * ONLY for audio — OpenAI's input_audio.data API field mandates base64 encoding.
- * There is no upload alternative for audio in the OpenAI API.
- *
- * For images/video/documents: ALWAYS use resolveMediaUrlViaUpload() instead.
- * base64 is forbidden for non-audio media per project architecture rules.
- */
-export declare function resolveMediaUrl(url: string, fallbackMime?: string): Promise<string>;

package/dist/types/llm/transports/minimax-media.d.ts

@@ -1,55 +0,0 @@
-/**
- * MiniMax Media Transport — Music + Video Generation.
- *
- * Music: POST /v1/music_generation (sync or async poll)
- * Video: POST /v1/video_generation (4 modes: text, image, first-last-frame, subject-ref)
- * Video Query: GET /v1/query/video_generation?task_id=XXX
- * File Retrieve: GET /v1/files/retrieve?file_id=XXX (get download_url)
- *
- * Auth: Authorization: Bearer $MINIMAX_API_KEY
- * Docs: minimax-ProviderMax.md §13-18 (video), §21 (music), §24-28 (files)
- */
-import type { AsyncMediaTransport, MediaRequest, MediaResult, MediaType } from "../media-transport.js";
-export interface MiniMaxMediaConfig {
-    /** Base URL, e.g. "https://api.minimaxi.com" */
-    baseUrl: string;
-    timeoutMs?: number;
-}
-export declare class MiniMaxMediaTransport implements AsyncMediaTransport {
-    readonly supportedTypes: readonly MediaType[];
-    private baseUrl;
-    private timeoutMs;
-    constructor(config: MiniMaxMediaConfig);
-    generate(request: MediaRequest, apiKey: string, signal?: AbortSignal): Promise<MediaResult>;
-    private generateMusic;
-    private pollTask;
-    /**
-     * Generate lyrics from a text prompt via MiniMax Lyrics Generation API.
-     * POST /v1/lyrics_generation — returns structured lyrics with tags.
-     */
-    generateLyrics(prompt: string, apiKey: string, signal?: AbortSignal): Promise<string>;
-    private generateVideo;
-    private pollVideoTask;
-    private getFileDownloadUrl;
-    /**
-     * Query a single video task by ID.
-     * GET /v1/query/video_generation?task_id=XXX
-     */
-    getTaskStatus(taskId: string, apiKey: string, signal?: AbortSignal): Promise<{
-        status: string;
-        task: Record<string, unknown>;
-    }>;
-    /**
-     * List tasks — MiniMax does not have a bulk list endpoint.
-     * Each task must be queried individually with getTaskStatus().
-     */
-    listVideoTasks(_apiKey: string, _options?: {
-        after?: string;
-        limit?: number;
-        status?: string;
-    }, _signal?: AbortSignal): Promise<Record<string, unknown>>;
-    /**
-     * Cancel/delete is not natively supported by MiniMax video API.
-     */
-    deleteVideoTask(_taskId: string, _apiKey: string, _signal?: AbortSignal): Promise<void>;
-}

package/dist/types/llm/transports/openai-chat.d.ts

@@ -1,81 +0,0 @@
-/**
- * OpenAI Chat Completions Transport 鈥?SSE streaming implementation.
- *
- * Covers all OpenAI-compatible providers:
- *   DeepSeek, Qwen, Minimax, Moonshot, OpenRouter, etc.
- *
- * POST {baseUrl}/v1/chat/completions with stream: true
- * Auth: Authorization: Bearer {apiKey}
- *
- * SSE format: lines prefixed with "data: ", JSON parsing per event.
- *
- * Adapted from admin-infer-proxy-client.ts SSE logic + Hermes openai_chat.py transport.
- */
-import type { LLMChunk, LLMRequest, LLMTransport, FIMRequest, FIMChunk } from "../transport.js";
-import type { ProviderQuirks } from "../provider-def.js";
-import type { FileUploadAdapter } from "../file-upload-service.js";
-export interface OpenAIChatTransportConfig {
-    baseUrl: string;
-    /** Additional headers (e.g. for specific providers) */
-    extraHeaders?: Record<string, string>;
-    /** Timeout in ms (default 180_000) */
-    timeoutMs?: number;
-    /** Whether to include stream_options (default true). Set false for providers that reject it. */
-    supportsStreamOptions?: boolean;
-    /** Whether to omit temperature when it equals 0 (e.g. Moonshot rejects 0) */
-    omitZeroTemperature?: boolean;
-    /** Provider-specific quirks (CC/altcode parity) */
-    quirks?: ProviderQuirks;
-    /** File upload adapter for resolving local media URLs via upload instead of base64. */
-    fileUploadAdapter?: FileUploadAdapter;
-}
-export declare class OpenAIChatTransport implements LLMTransport {
-    private baseUrl;
-    private extraHeaders;
-    private timeoutMs;
-    private supportsStreamOptions;
-    private omitZeroTemperature;
-    private quirks;
-    private fileUploadAdapter?;
-    private cumulativeReasoningLen;
-    private cumulativeContentLen;
-    constructor(config: OpenAIChatTransportConfig);
-    stream(request: LLMRequest, apiKey: string, signal?: AbortSignal): AsyncGenerator<LLMChunk>;
-    private fetchAndStream;
-    /**
-     * Handle non-streaming JSON response from providers that ignore stream:true.
-     * Synthesize the same LLMChunk events a streaming response would produce.
-     */
-    private handleNonStreamingResponse;
-    /**
-     * Parse SSE stream with 90s idle watchdog (CC parity).
-     * If no data arrives within STREAM_IDLE_TIMEOUT_MS, throw to trigger retry.
-     */
-    private parseSSEStreamWithWatchdog;
-    private processChunk;
-    /**
-     * FIM completion via /beta/v1/completions.
-     * Only works with DeepSeek (requires supportsPrefixCompletion quirk).
-     * Non-thinking mode only; max completion 4K tokens.
-     */
-    complete(request: FIMRequest, apiKey: string, signal?: AbortSignal): AsyncGenerator<FIMChunk>;
-    /**
-     * Upload a file for use in conversations (Kimi File API).
-     * Returns a file_id that can be referenced in user messages.
-     * POST /v1/files with multipart/form-data.
-     */
-    uploadFile(fileBlob: Blob, filename: string, purpose: string, apiKey: string, signal?: AbortSignal): Promise<{
-        fileId: string;
-        filename: string;
-        bytes: number;
-    }>;
-    /**
-     * Get file content/status 鈥?GET /v1/files/{file_id}
-     */
-    getFileInfo(fileId: string, apiKey: string, signal?: AbortSignal): Promise<{
-        id: string;
-        filename: string;
-        bytes: number;
-        status: string;
-    }>;
-}

package/dist/types/llm/transports/openai-media.d.ts

@@ -1,24 +0,0 @@
-/**
- * OpenAI Media Transport — Images API (gpt-image-2) + Audio Speech API (tts-1).
- *
- * Image:  POST /v1/images/generations (sync response, returns URLs)
- * TTS:    POST /v1/audio/speech      (sync response, returns raw audio bytes)
- * Auth: Authorization: Bearer $OPENAI_API_KEY
- * Docs: https://platform.openai.com/docs/api-reference/images/create
- *       https://platform.openai.com/docs/api-reference/audio/createSpeech
- */
-import type { MediaTransport, MediaRequest, MediaResult, MediaType } from "../media-transport.js";
-export interface OpenAIMediaConfig {
-    /** Base URL, e.g. "https://api.openai.com" */
-    baseUrl: string;
-    timeoutMs?: number;
-}
-export declare class OpenAIMediaTransport implements MediaTransport {
-    readonly supportedTypes: readonly MediaType[];
-    private baseUrl;
-    private timeoutMs;
-    constructor(config: OpenAIMediaConfig);
-    generate(request: MediaRequest, apiKey: string, signal?: AbortSignal): Promise<MediaResult>;
-    private generateImage;
-    private generateTTS;
-}

package/dist/types/llm/transports/openai-responses.d.ts

@@ -1,63 +0,0 @@
-/**
- * OpenAI Responses API Transport 鈥?SSE streaming implementation.
- *
- * Implements the OpenAI Responses API (`POST /v1/responses`),
- * the officially recommended path for GPT-5.x text generation.
- *
- * Key differences from OpenAI Chat Completions:
- *   - Endpoint: POST {baseUrl}/v1/responses
- *   - Request body uses `input` (not `messages`), `instructions`, `reasoning`
- *   - SSE events: response.output_text.delta, response.function_call_arguments.delta,
- *     response.completed, etc.
- *   - Tool defs: { type: "function", name, parameters } (not nested under `function:`)
- *   - Tool results: { type: "function_call_output", call_id, output }
- *   - Context persistence: previous_response_id for server-side session continuation
- *   - Structured output: `text: { format: { type: "json_schema", ... } }`
- *   - Reasoning: `reasoning: { effort, summary }` for GPT-5.x models
- *
- * Wire format reference:
- *   https://developers.openai.com/api/docs/api-reference/responses/create
- *   https://developers.openai.com/api/docs/api-reference/responses/streaming-events
- *
- * Design: Closely mirrors volcengine-responses.ts patterns while adapting to
- * OpenAI-specific wire format. Shared LLMChunk output makes upper layers
- * transport-agnostic.
- */
-import type { LLMChunk, LLMRequest, LLMTransport } from "../transport.js";
-import type { ProviderQuirks } from "../provider-def.js";
-import type { FileUploadAdapter } from "../file-upload-service.js";
-export interface OpenAIResponsesTransportConfig {
-    baseUrl: string;
-    extraHeaders?: Record<string, string>;
-    timeoutMs?: number;
-    quirks?: ProviderQuirks;
-    fileUploadAdapter?: FileUploadAdapter;
-}
-export declare class OpenAIResponsesTransport implements LLMTransport {
-    private baseUrl;
-    private extraHeaders;
-    private timeoutMs;
-    private quirks;
-    private fileUploadAdapter?;
-    constructor(config: OpenAIResponsesTransportConfig);
-    stream(request: LLMRequest, apiKey: string, signal?: AbortSignal): AsyncGenerator<LLMChunk>;
-    private buildRequestBody;
-    private fetchAndStream;
-    private handleNonStreamingResponse;
-    /**
-     * Parse OpenAI Responses API SSE stream.
-     *
-     * Event format: "event: <type>\ndata: <json>\n\n"
-     * Key events:
-     *   - response.output_text.delta           鈫?text content delta
-     *   - response.reasoning_summary_text.delta 鈫?reasoning summary text
-     *   - response.function_call_arguments.delta 鈫?tool call arguments streaming
-     *   - response.output_item.added           鈫?new output item started
-     *   - response.output_item.done            鈫?output item completed
-     *   - response.content_part.done           鈫?content part completed (annotations)
-     *   - response.completed                   鈫?full response complete with usage
-     *   - response.failed                      鈫?error
-     */
-    private parseSSEStream;
-    private processEvent;
-}

package/dist/types/llm/transports/qwen-media.d.ts

@@ -1,50 +0,0 @@
-/**
- * Qwen (DashScope) Media Transport — TTS + Video Generation.
- *
- * DashScope async task API pattern:
- *   Submit: POST /api/v1/services/aigc/<service>/generation  (X-DashScope-Async: enable)
- *   Poll:   GET  /api/v1/tasks/{taskId}
- *
- * Auth: Authorization: Bearer $DASHSCOPE_API_KEY
- * Docs: https://help.aliyun.com/zh/model-studio/developer-reference/
- *
- * Video models: wan2.7-t2v (text-to-video), wan2.7-i2v (image-to-video)
- * TTS models: qwen3-tts-voicedesign, cosyvoice-v2
- */
-import type { AsyncMediaTransport, MediaRequest, MediaResult, MediaType } from "../media-transport.js";
-export interface QwenMediaConfig {
-    /** Base URL, e.g. "https://dashscope.aliyuncs.com" */
-    baseUrl: string;
-    timeoutMs?: number;
-}
-export declare class QwenMediaTransport implements AsyncMediaTransport {
-    readonly supportedTypes: readonly MediaType[];
-    private baseUrl;
-    private timeoutMs;
-    constructor(config: QwenMediaConfig);
-    generate(request: MediaRequest, apiKey: string, signal?: AbortSignal): Promise<MediaResult>;
-    private pollTask;
-    private generateVideo;
-    /**
-     * Query a single task by ID using DashScope unified task endpoint.
-     * GET /api/v1/tasks/{taskId}
-     */
-    getTaskStatus(taskId: string, apiKey: string, signal?: AbortSignal): Promise<{
-        status: string;
-        task: Record<string, unknown>;
-    }>;
-    /**
-     * List tasks — DashScope has a task list API.
-     * GET /api/v1/tasks?page_no=1&page_size=20&status=RUNNING
-     */
-    listVideoTasks(apiKey: string, options?: {
-        after?: string;
-        limit?: number;
-        status?: string;
-    }, signal?: AbortSignal): Promise<Record<string, unknown>>;
-    /**
-     * Cancel/delete — DashScope does not have a public task cancellation API.
-     */
-    deleteVideoTask(_taskId: string, _apiKey: string, _signal?: AbortSignal): Promise<void>;
-    private extractMediaUrl;
-}

package/dist/types/llm/transports/realtime-transport.d.ts

@@ -1,183 +0,0 @@
-/**
- * Realtime WebSocket Transport — bidirectional audio/voice streaming
- * via the OpenAI Realtime API protocol (also compatible with GLM Realtime).
- *
- * ## Protocol: WebSocket JSON events
- *
- * Client → Server:
- *   - session.update: configure session (model, voice, tools, etc.)
- *   - input_audio_buffer.append: send audio chunks (base64 PCM16)
- *   - input_audio_buffer.commit: signal end of audio input
- *   - conversation.item.create: inject text/function_result items
- *   - response.create: request a model response
- *   - response.cancel: abort in-progress response
- *
- * Server → Client:
- *   - session.created: session initialized
- *   - session.updated: config acknowledged
- *   - input_audio_buffer.speech_started: VAD detected speech
- *   - input_audio_buffer.speech_stopped: VAD detected silence
- *   - response.created: response generation started
- *   - response.output_item.added: new output item (text/audio/function_call)
- *   - response.audio.delta: audio chunk (base64 PCM16)
- *   - response.audio_transcript.delta: transcript of generated speech
- *   - response.text.delta: text generation delta
- *   - response.function_call_arguments.delta: tool call args delta
- *   - response.function_call_arguments.done: tool call complete
- *   - response.output_item.done: output item finished
- *   - response.done: full response complete
- *   - error: server error
- *
- * ## Architecture
- *
- * RealtimeTransport manages a single persistent WebSocket connection per session.
- * It exposes an event-driven API (AsyncGenerator) that the agent tool-loop
- * can consume for voice-enabled interactions.
- *
- * Docs:
- *   - OpenAI: https://platform.openai.com/docs/api-reference/realtime
- *   - GLM:    https://docs.bigmodel.cn/cn/guide/develop/realtime-api
- */
-export interface RealtimeConfig {
-    /** WebSocket endpoint (e.g. "wss://api.openai.com/v1/realtime") */
-    baseUrl: string;
-    /** Model to use (e.g. "gpt-realtime-2", "glm-realtime") */
-    model: string;
-    /** API key */
-    apiKey: string;
-    /** Voice for TTS output */
-    voice?: string;
-    /** Input modalities: "text", "audio", or both */
-    inputModalities?: Array<"text" | "audio">;
-    /** Output modalities: "text", "audio", or both */
-    outputModalities?: Array<"text" | "audio">;
-    /** Temperature for generation */
-    temperature?: number;
-    /** Tool definitions for function calling */
-    tools?: RealtimeTool[];
-    /** Voice Activity Detection mode */
-    vadMode?: "server_vad" | "none";
-    /** VAD threshold (0.0-1.0) */
-    vadThreshold?: number;
-    /** Auth type: "header" (OpenAI) or "query" (GLM) */
-    authMode?: "header" | "query";
-}
-export interface RealtimeTool {
-    type: "function";
-    name: string;
-    description: string;
-    parameters: Record<string, unknown>;
-}
-export type RealtimeEvent = {
-    type: "session_created";
-    sessionId: string;
-} | {
-    type: "speech_started";
-} | {
-    type: "speech_stopped";
-    audioEndMs: number;
-} | {
-    type: "audio_delta";
-    delta: string;
-} | {
-    type: "audio_transcript_delta";
-    delta: string;
-} | {
-    type: "text_delta";
-    delta: string;
-} | {
-    type: "function_call_start";
-    callId: string;
-    name: string;
-} | {
-    type: "function_call_delta";
-    callId: string;
-    delta: string;
-} | {
-    type: "function_call_done";
-    callId: string;
-    name: string;
-    arguments: string;
-} | {
-    type: "response_done";
-    usage?: RealtimeUsage;
-} | {
-    type: "error";
-    code: string;
-    message: string;
-} | {
-    type: "closed";
-    code: number;
-    reason: string;
-};
-export interface RealtimeUsage {
-    inputTokens: number;
-    outputTokens: number;
-    inputAudioTokens?: number;
-    outputAudioTokens?: number;
-}
-/**
- * Manages a persistent WebSocket connection for real-time audio/voice
- * interactions with an LLM provider.
- *
- * Usage:
- * ```ts
- * const rt = new RealtimeTransport(config);
- * rt.connect();
- *
- * // Send audio
- * rt.appendAudio(base64Chunk);
- * rt.commitAudio();
- *
- * // Or send text
- * rt.sendText("Hello!");
- *
- * // Submit function results
- * rt.sendFunctionResult(callId, result);
- *
- * // Consume events
- * for await (const event of rt.events()) {
- *   switch (event.type) {
- *     case "audio_delta": playAudio(event.delta); break;
- *     case "function_call_done": handleToolCall(event); break;
- *   }
- * }
- *
- * rt.close();
- * ```
- */
-export declare class RealtimeTransport {
-    private ws;
-    private config;
-    private eventQueue;
-    private waiters;
-    private closed;
-    constructor(config: RealtimeConfig);
-    /** Open WebSocket connection and configure session. */
-    connect(): Promise<void>;
-    /** Send audio data (base64 PCM16). */
-    appendAudio(base64Chunk: string): void;
-    /** Mark end of audio input and trigger response. */
-    commitAudio(): void;
-    /** Send a text message. */
-    sendText(text: string): void;
-    /** Submit a function call result back to the model. */
-    sendFunctionResult(callId: string, output: string): void;
-    /** Trigger a model response (e.g. after sending text). */
-    requestResponse(): void;
-    /** Cancel an in-progress response. */
-    cancelResponse(): void;
-    /** Async iterator of server events. */
-    events(): AsyncGenerator<RealtimeEvent>;
-    /** Close the WebSocket connection. */
-    close(): void;
-    private buildUrl;
-    private sendSessionUpdate;
-    private send;
-    private push;
-    private drainWaiters;
-    /**
-     * Parse a server-sent JSON event into our typed event(s).
-     */
-    private parseServerEvent;
-}

package/dist/types/llm/transports/volcengine-grounding.d.ts

@@ -1,58 +0,0 @@
-/**
- * Volcengine Grounding — spatial coordinate parser (volcengine-ProviderMax §14).
- *
- * Parses model-emitted spatial reference tags from text output:
- *   - <bbox>x_min y_min x_max y_max</bbox>   → bounding box
- *   - <point>x y</point>                       → single point
- *   - <polygon>x1 y1 x2 y2 ...</polygon>       → polygon vertices
- *
- * All coordinates are in normalized 1000×1000 space, range [0, 999].
- * Use `toPixelCoords()` to convert to actual image pixel coordinates.
- */
-export type SpatialReference = {
-    type: "bbox";
-    x1: number;
-    y1: number;
-    x2: number;
-    y2: number;
-    space: "normalized_1000";
-} | {
-    type: "point";
-    x: number;
-    y: number;
-    space: "normalized_1000";
-} | {
-    type: "polygon";
-    points: Array<{
-        x: number;
-        y: number;
-    }>;
-    space: "normalized_1000";
-};
-export interface PixelBbox {
-    x1: number;
-    y1: number;
-    x2: number;
-    y2: number;
-}
-export interface PixelPoint {
-    x: number;
-    y: number;
-}
-/**
- * Extract all spatial references from model output text.
- * Returns an empty array if no grounding tags are found.
- */
-export declare function parseGroundingTags(text: string): SpatialReference[];
-/**
- * Convert a normalized 1000×1000 bounding box to pixel coordinates.
- */
-export declare function bboxToPixels(ref: Extract<SpatialReference, {
-    type: "bbox";
-}>, width: number, height: number): PixelBbox;
-/**
- * Convert a normalized 1000×1000 point to pixel coordinates.
- */
-export declare function pointToPixels(ref: Extract<SpatialReference, {
-    type: "point";
-}>, width: number, height: number): PixelPoint;