@j-o-r/hello-dave 0.0.10 → 0.1.0

package/types/API/minimax/video.d.ts

@@ -0,0 +1,165 @@
+/**
+ * Get authentication headers for Minimax API.
+ *
+ * @returns {Object} Headers object with Authorization Bearer token.
+ * @throws {Error} If MINIMAX_API_KEY environment variable is not set.
+ */
+export function getHeaders(): Object;
+/**
+ * Saves video data from a download URL to a local temporary file.
+ * Handles MP4 videos.
+ *
+ * @param {string} videoUrl - Public download URL from retrieveVideoFile().
+ * @param {string} [filenamePrefix='minimax-video'] - Prefix for the local filename.
+ * @returns {Promise<string>} Absolute path to the saved local file.
+ */
+export function saveVideoToLocal(videoUrl: string, filenamePrefix?: string): Promise<string>;
+/**
+ * Creates a video generation task (Text-to-Video, Image-to-Video, First-Last, Subject-Ref).
+ *
+ * Uses POST /v1/video_generation.
+ * Supports all documented models and input types via options.
+ *
+ * @param {string} [prompt] - Text description (required for most modes).
+ * @param {Object} [options]
+ *
+ * @param {string} [options.model='MiniMax-Hailuo-2.3'] - Default model.
+ *   Supported: MiniMax-Hailuo-2.3, MiniMax-Hailuo-02, T2V-01, I2V-01, S2V-01, etc.
+ *
+ * @param {string} [options.first_frame_image] - URL or data: URL for image-to-video / first-last.
+ * @param {string} [options.last_frame_image] - For first & last frame mode.
+ * @param {Array<Object>} [options.subject_reference] - For subject-reference mode.
+ *
+ * @param {boolean} [options.prompt_optimizer=true]
+ * @param {boolean} [options.fast_pretreatment=false]
+ * @param {number} [options.duration=6]
+ * @param {string} [options.resolution] - e.g. '768P', '1080P'
+ * @param {string} [options.callback_url]
+ *
+ * @returns {Promise<{task_id: string, raw: object}>}
+ */
+export function createVideoGenerationTask(prompt?: string, options?: {
+    model?: string | undefined;
+    first_frame_image?: string | undefined;
+    last_frame_image?: string | undefined;
+    subject_reference?: Object[] | undefined;
+    prompt_optimizer?: boolean | undefined;
+    fast_pretreatment?: boolean | undefined;
+    duration?: number | undefined;
+    resolution?: string | undefined;
+    callback_url?: string | undefined;
+}): Promise<{
+    task_id: string;
+    raw: object;
+}>;
+/**
+ * Queries the status of a video generation task.
+ *
+ * GET /v1/query/video_generation?task_id=...
+ *
+ * @param {string} taskId
+ * @returns {Promise<{
+ *   task_id: string,
+ *   status: 'Preparing' | 'Queueing' | 'Processing' | 'Success' | 'Fail',
+ *   file_id?: string,
+ *   video_width?: number,
+ *   video_height?: number,
+ *   raw: object
+ * }>}
+ */
+export function queryVideoGenerationTask(taskId: string): Promise<{
+    task_id: string;
+    status: "Preparing" | "Queueing" | "Processing" | "Success" | "Fail";
+    file_id?: string;
+    video_width?: number;
+    video_height?: number;
+    raw: object;
+}>;
+/**
+ * Retrieves file metadata and download URL for a completed video.
+ *
+ * GET /v1/files/retrieve?file_id=...
+ *
+ * @param {string|number} fileId
+ * @returns {Promise<{
+ *   file_id: string,
+ *   filename: string,
+ *   download_url: string,
+ *   bytes: number,
+ *   raw: object
+ * }>}
+ */
+export function retrieveVideoFile(fileId: string | number): Promise<{
+    file_id: string;
+    filename: string;
+    download_url: string;
+    bytes: number;
+    raw: object;
+}>;
+/**
+ * High-level video generation function.
+ * Handles the full async flow: create task → poll until ready → retrieve → download to .cache/minimax/
+ *
+ * Supports all video generation modes (text, image-to-video, first-last, subject-ref)
+ * by passing the appropriate options.
+ *
+ * @param {string} prompt - Text prompt (can be empty for some modes).
+ * @param {Object} [options] - Same as createVideoGenerationTask + polling options.
+ *
+ * @param {number} [options.max_wait_ms=300000]
+ * @param {number} [options.poll_interval_ms=5000]
+ *
+ * @returns {Promise<{
+ *   task_id: string,
+ *   file_id: string,
+ *   video_url: string,           // download_url
+ *   local_path: string,          // path in .cache/minimax/
+ *   video_width: number,
+ *   video_height: number,
+ *   duration: number,            // total time including polling
+ *   raw: object
+ * }>}
+ *
+ * @example
+ * // Text-to-Video
+ * const result = await generateVideo("A cat jumping on a table [Pan left]", {
+ *   model: "MiniMax-Hailuo-2.3",
+ *   duration: 6,
+ *   resolution: "768P"
+ * });
+ *
+ * @example
+ * // Image-to-Video
+ * const result = await generateVideo("The character walks forward", {
+ *   model: "MiniMax-Hailuo-2.3",
+ *   first_frame_image: "https://example.com/image.jpg"
+ * });
+ */
+export function generateVideo(prompt?: string, options?: {
+    max_wait_ms?: number | undefined;
+    poll_interval_ms?: number | undefined;
+}): Promise<{
+    task_id: string;
+    file_id: string;
+    video_url: string;
+    local_path: string;
+    video_width: number;
+    video_height: number;
+    duration: number;
+    raw: object;
+}>;
+/**
+ * Internal helper: Waits for video generation task to complete by polling.
+ *
+ * @param {string} taskId
+ * @param {number} [maxWaitMs=300000] - Max wait time (5 minutes default)
+ * @param {number} [pollIntervalMs=5000] - Poll every 5 seconds
+ * @returns {Promise<{status: string, file_id?: string, video_width?: number, video_height?: number, raw: object}>}
+ */
+export function waitForVideoReady(taskId: string, maxWaitMs?: number, pollIntervalMs?: number): Promise<{
+    status: string;
+    file_id?: string;
+    video_width?: number;
+    video_height?: number;
+    raw: object;
+}>;

package/types/API/stability.ai/ImageToolset.d.ts

@@ -0,0 +1,3 @@
+export default tools;
+declare const tools: ToolSet;
+import ToolSet from '../../ToolSet.js';

package/types/API/stability.ai/MusicToolset.d.ts

@@ -0,0 +1,3 @@
+export default tools;
+declare const tools: ToolSet;
+import ToolSet from '../../ToolSet.js';

package/types/API/stability.ai/audio.d.ts

@@ -0,0 +1,193 @@
+/**
+ * Builds authenticated headers for Stability AI requests.
+ *
+ * @param {string} [acceptHeader='audio/*'] - Accept header value.
+ *        Use `'audio/*'` for binary audio response or `'application/json'` for base64 JSON.
+ * @returns {Object} Headers object containing Authorization (Bearer) and Accept.
+ * @throws {Error} If `STABILITY_API_KEY` environment variable is not set.
+ *
+ * @example
+ * const headers = getHeaders('application/json');
+ */
+export function getHeaders(acceptHeader?: string): Object;
+/**
+ * Saves audio data (Buffer, base64 string, URL, Blob, or ArrayBuffer) to a local file.
+ *
+ * @async
+ * @param {Buffer|string|Blob|ArrayBuffer} audioData - Audio content to save.
+ *        - Buffer: raw bytes
+ *        - string starting with 'http': remote URL (auto-downloaded)
+ *        - base64 string: decoded
+ *        - Blob/ArrayBuffer: converted
+ * @param {string} [filenamePrefix='stability-audio'] - Prefix for the generated filename.
+ * @param {string} [ext='mp3'] - File extension (`mp3` or `wav` recommended).
+ * @returns {Promise<string>} Absolute local file path of the saved audio.
+ * @throws {Error} For unsupported formats or download failures.
+ */
+export function saveAudioToLocal(audioData: Buffer | string | Blob | ArrayBuffer, filenamePrefix?: string, ext?: string): Promise<string>;
+/**
+ * Generates high-quality audio from a text prompt using Stable Audio 3.
+ *
+ * This is the primary text-to-audio endpoint. It submits a prompt and optional
+ * parameters, receives a generation ID (202), polls until ready, and returns
+ * the generated audio saved locally plus metadata.
+ *
+ * **Constraints** (from Stable Audio 3 spec):
+ * - Prompt: English only, max 10,000 characters, descriptive (instruments, mood, genre, style).
+ * - Duration: 1–380 seconds (default 190).
+ * - Steps: 4–8 (default 8).
+ * - CFG Scale: 1–25 (default 1).
+ * - Seed: 0 (random) or 0–4,294,967,294.
+ * - Output: mp3 (default) or wav at 44.1 kHz stereo.
+ * - Cost: Flat 26 credits per successful generation.
+ *
+ * @async
+ * @function textToAudio
+ * @param {string} prompt - Required descriptive text prompt. Must be non-empty English string.
+ * @param {Object} [options={}] - Optional generation parameters.
+ * @param {string} [options.model='stable-audio-3'] - Model identifier. Must be exactly `'stable-audio-3'`.
+ * @param {number} [options.duration=190] - Target duration in seconds (1 ≤ duration ≤ 380).
+ * @param {number} [options.seed=0] - Random seed for reproducibility (0 = random).
+ * @param {number} [options.steps=8] - Number of sampling steps (4–8).
+ * @param {number} [options.cfg_scale=1] - Prompt adherence strength (1–25).
+ * @param {string} [options.output_format='mp3'] - `'mp3'` or `'wav'`.
+ * @param {string} [options.accept='audio/*'] - Response format: `'audio/*'` (binary) or `'application/json'`.
+ * @param {string} [options.filenamePrefix='stability-text-to-audio'] - Prefix for saved file.
+ * @returns {Promise<Object>} Result object:
+ *          ```js
+ *          {
+ *            local_path: '/path/to/.cache/stability/stability-text-to-audio-1234567890.mp3',
+ *            finish_reason: 'SUCCESS',
+ *            seed: 123456789,
+ *            x_request_id: 'req_...',
+ *            raw: { headers: {...} }   // or full JSON if accept=application/json
+ *          }
+ *          ```
+ * @throws {Error} - 'Missing STABILITY_API_KEY', invalid prompt, unsupported model,
+ *                   API errors (400/403/422/429/500), polling timeout, or download failures.
+ *
+ * @example
+ * // Basic usage
+ * const result = await textToAudio('upbeat electronic synthwave with driving bass');
+ * console.log('Saved to:', result.local_path);
+ *
+ * @example
+ * // Advanced with options
+ * const result = await textToAudio(
+ *   'cinematic orchestral music, epic brass, strings, choir, 120 BPM',
+ *   {
+ *     duration: 240,
+ *     seed: 42,
+ *     steps: 8,
+ *     cfg_scale: 7,
+ *     output_format: 'wav',
+ *     accept: 'application/json'
+ *   }
+ * );
+ * if (result.audio_base64) {
+ *   // handle base64
+ * }
+ */
+export function textToAudio(prompt: string, options?: {
+    model?: string | undefined;
+    duration?: number | undefined;
+    seed?: number | undefined;
+    steps?: number | undefined;
+    cfg_scale?: number | undefined;
+    output_format?: string | undefined;
+    accept?: string | undefined;
+    filenamePrefix?: string | undefined;
+}): Promise<Object>;
+/**
+ * Transforms an existing audio sample using a text prompt (audio-to-audio / style transfer).
+ *
+ * Uploads a reference audio file (or URL) and applies the prompt to generate a new
+ * composition that incorporates elements of the input while following the text description.
+ *
+ * **Additional Parameter**:
+ * - `strength`: Denoising strength (0.0 = identical to input, 1.0 = no influence from input).
+ *
+ * All other constraints and behavior are identical to `textToAudio`.
+ *
+ * @async
+ * @function audioToAudio
+ * @param {string} prompt - Descriptive text prompt (English, max 10k chars).
+ * @param {string|Buffer|Blob} audioInput - Reference audio:
+ *        - Local file path (string)
+ *        - Remote HTTP/HTTPS URL (string) – auto-downloaded with proper MIME
+ *        - Buffer (raw bytes)
+ *        - Blob (with optional name/type)
+ * @param {Object} [options={}] - Generation options (see textToAudio for common params).
+ * @param {number} [options.strength=1] - Denoising strength (0–1).
+ * @param {string} [options.filenamePrefix='stability-audio-to-audio']
+ * @returns {Promise<Object>} Same structure as textToAudio result.
+ * @throws {Error} Same as textToAudio plus audio input validation errors.
+ *
+ * @example
+ * const result = await audioToAudio(
+ *   'transform into orchestral version with strings and choir',
+ *   './reference-track.mp3',
+ *   { strength: 0.75, duration: 180 }
+ * );
+ */
+export function audioToAudio(prompt: string, audioInput: string | Buffer | Blob, options?: {
+    strength?: number | undefined;
+    filenamePrefix?: string | undefined;
+}): Promise<Object>;
+/**
+ * Performs audio inpainting: replaces a specified time segment of an audio file
+ * with new content generated from a text prompt.
+ *
+ * Uses `mask_start` and `mask_end` to define the region to inpaint (in seconds).
+ * The model fills the masked section while preserving the rest of the audio.
+ *
+ * Default mask: 30s → 380s (inpaint most of a long track).
+ *
+ * @async
+ * @function inpaint
+ * @param {string} prompt - Text prompt describing the desired replacement content.
+ * @param {string|Buffer|Blob} audioInput - Reference audio (same as audioToAudio).
+ * @param {Object} [options={}] - Generation options.
+ * @param {number} [options.mask_start=30] - Start time (seconds) of the inpaint mask (0–380).
+ * @param {number} [options.mask_end=380] - End time (seconds) of the inpaint mask (0–380).
+ * @param {string} [options.filenamePrefix='stability-inpaint']
+ * @returns {Promise<Object>} Same result structure as other generation methods.
+ * @throws {Error} Validation errors for mask ranges, audio input, etc.
+ *
+ * @example
+ * // Inpaint the middle section
+ * const result = await inpaint(
+ *   'add a soaring guitar solo in this section',
+ *   'full-track.mp3',
+ *   { mask_start: 60, mask_end: 120, duration: 180 }
+ * );
+ */
+export function inpaint(prompt: string, audioInput: string | Buffer | Blob, options?: {
+    mask_start?: number | undefined;
+    mask_end?: number | undefined;
+    filenamePrefix?: string | undefined;
+}): Promise<Object>;
+/**
+ * Manually fetches or checks the status of a generation using its ID.
+ * Useful for custom polling logic or resuming after a previous submission.
+ *
+ * @async
+ * @function fetchResult
+ * @param {string} id - Generation ID (from a previous 202 response).
+ * @param {string} [acceptHeader='audio/*'] - `'audio/*'` or `'application/json'`.
+ * @returns {Promise<Object>} Either:
+ *          - Completed result (same as processResult)
+ *          - `{ status: 'in-progress', id, raw }` if still 202
+ * @throws {Error} If ID missing, 404 (expired), or other API error.
+ *
+ * @example
+ * // Manual polling example
+ * const id = await submit...; // or from previous call
+ * let result;
+ * while (true) {
+ *   result = await fetchResult(id);
+ *   if (result.status !== 'in-progress') break;
+ *   await new Promise(r => setTimeout(r, 5000));
+ * }
+ */
+export function fetchResult(id: string, acceptHeader?: string): Promise<Object>;

package/types/API/stability.ai/image.d.ts

@@ -0,0 +1,274 @@
+/**
+ * Builds authenticated headers for Stability AI requests.
+ *
+ * @param {string} [acceptHeader='image/*'] - Accept header value.
+ *        Use `'image/*'` for binary image response or `'application/json'` for base64 JSON.
+ * @returns {Object} Headers object containing Authorization (Bearer) and Accept.
+ * @throws {Error} If `STABILITY_API_KEY` environment variable is not set.
+ */
+export function getHeaders(acceptHeader?: string): Object;
+/**
+ * Saves image data (Buffer, base64 string, URL, Blob, or ArrayBuffer) to a local file.
+ *
+ * @async
+ * @param {Buffer|string|Blob|ArrayBuffer} imageData - Image content to save.
+ * @param {string} [filenamePrefix='stability-image'] - Prefix for the generated filename.
+ * @param {string} [ext='png'] - File extension (`png`, `jpeg`, `webp`).
+ * @returns {Promise<string>} Absolute local file path of the saved image.
+ * @throws {Error} For unsupported formats or download failures.
+ */
+export function saveImageToLocal(imageData: Buffer | string | Blob | ArrayBuffer, filenamePrefix?: string, ext?: string): Promise<string>;
+/**
+ * Generates the highest quality photorealistic image using Stable Image Ultra.
+ *
+ * Our most advanced text-to-image model based on Stable Diffusion 3.5.
+ * Produces exceptional detail, realism, and prompt adherence — ideal for professional print and large-format applications.
+ *
+ * **Constraints** (from Stable Image Ultra spec):
+ * - Prompt: Max 10,000 characters. Strong descriptive prompt recommended.
+ * - Aspect ratio: One of `1:1` (default), `16:9`, `9:16`, `21:9`, `9:21`, `2:3`, `3:2`, `4:5`, `5:4`.
+ * - Image-to-image: Provide `image` + `strength` (0–1). Image must be 64px–16,384px per side.
+ * - Output resolution: 1 megapixel (default 1024×1024).
+ * - Cost: 8 credits per successful generation.
+ * - Output formats: `png` (default), `jpeg`, `webp`.
+ *
+ * @async
+ * @function generateUltra
+ * @param {string} prompt - Required descriptive prompt. Must be non-empty English string (max 10,000 chars).
+ * @param {Object} [options={}] - Optional generation parameters.
+ * @param {string} [options.negative_prompt] - Keywords describing what you do **not** want to see.
+ * @param {string} [options.aspect_ratio='1:1'] - Controls aspect ratio of the output image.
+ * @param {number} [options.seed=0] - Specific seed for reproducibility (0 = random, 0–4,294,967,294).
+ * @param {string} [options.output_format='png'] - `'png'`, `'jpeg'`, or `'webp'`.
+ * @param {string|Buffer|Blob} [options.image] - Optional reference image for image-to-image generation.
+ * @param {number} [options.strength] - Denoising strength (0–1). Required when `image` is provided.
+ * @param {string} [options.style_preset] - Guides the model toward a particular style (e.g. 'photographic', 'cinematic').
+ * @param {string} [options.accept='image/*'] - `'image/*'` (binary) or `'application/json'` (base64).
+ * @param {string} [options.filenamePrefix='stability-ultra'] - Prefix for saved local file.
+ * @returns {Promise<Object>} Standardized result:
+ *          ```js
+ *          {
+ *            local_path: '/path/to/.cache/stability/stability-ultra-1234567890.png',
+ *            finish_reason: 'SUCCESS',
+ *            seed: 123456789,
+ *            x_request_id: 'req_...',
+ *            raw: { headers: {...} }   // or full JSON if accept=application/json
+ *          }
+ *          ```
+ * @throws {Error} - 'Missing STABILITY_API_KEY', invalid prompt, API errors (400/403/422/429/500), polling timeout, or download failures.
+ *
+ * @example
+ * // Basic text-to-image
+ * const result = await generateUltra('majestic mountain landscape at sunset, cinematic lighting');
+ * console.log('Saved to:', result.local_path);
+ *
+ * @example
+ * // Image-to-image with strength
+ * const result = await generateUltra(
+ *   'same scene but with dramatic storm clouds',
+ *   {
+ *     image: './reference.png',
+ *     strength: 0.65,
+ *     aspect_ratio: '16:9',
+ *     output_format: 'webp'
+ *   }
+ * );
+ */
+export function generateUltra(prompt: string, options?: {
+    negative_prompt?: string | undefined;
+    aspect_ratio?: string | undefined;
+    seed?: number | undefined;
+    output_format?: string | undefined;
+    image?: string | Buffer | Blob;
+    strength?: number | undefined;
+    style_preset?: string | undefined;
+    accept?: string | undefined;
+    filenamePrefix?: string | undefined;
+}): Promise<Object>;
+/**
+ * Generates fast and affordable images using Stable Image Core.
+ *
+ * Optimized for rapid iteration during ideation. Next-generation model following SDXL.
+ *
+ * **Constraints**:
+ * - Prompt: Max 10,000 characters.
+ * - Aspect ratio: Same options as Ultra.
+ * - Output resolution: 1.5 megapixels.
+ * - Cost: 3 credits per successful generation.
+ *
+ * @async
+ * @function generateCore
+ * @param {string} prompt - Required descriptive prompt.
+ * @param {Object} [options={}] - Optional parameters (negative_prompt, aspect_ratio, seed, output_format, style_preset, accept, filenamePrefix).
+ * @returns {Promise<Object>} Same result structure as generateUltra.
+ */
+export function generateCore(prompt: string, options?: Object): Promise<Object>;
+/**
+ * Generates images using Stable Diffusion 3.5 models.
+ *
+ * Supports `sd3.5-large`, `sd3.5-large-turbo`, `sd3.5-medium`, `sd3.5-flash`.
+ *
+ * **Key Parameters**:
+ * - `mode`: `'text-to-image'` (default) or `'image-to-image'`.
+ * - For image-to-image: `image` + `strength` required.
+ * - `cfg_scale`: Prompt adherence (default 4 for Large/Medium, 1 for Turbo/Flash).
+ *
+ * @async
+ * @function generateSD3
+ * @param {string} prompt - Required prompt.
+ * @param {Object} [options={}] - Optional parameters including `mode`, `model`, `image`, `strength`, `cfg_scale`, etc.
+ * @returns {Promise<Object>} Same result structure.
+ */
+export function generateSD3(prompt: string, options?: Object): Promise<Object>;
+/**
+ * Upscales an image conservatively while preserving original details.
+ *
+ * Takes images 64×64 to 1MP and upscales to 4MP with minimal alteration.
+ *
+ * **Constraints**:
+ * - Image: 64px–9,437,184 total pixels, aspect ratio 1:2.5 to 2.5:1.
+ * - Cost: 40 credits.
+ *
+ * @async
+ * @function upscaleConservative
+ * @param {string|Buffer|Blob} imageInput - Image to upscale.
+ * @param {string} prompt - Prompt describing desired output.
+ * @param {Object} [options={}] - Optional: negative_prompt, seed, output_format, creativity (0.2–0.5).
+ * @returns {Promise<Object>} Result with upscaled image.
+ */
+export function upscaleConservative(imageInput: string | Buffer | Blob, prompt: string, options?: Object): Promise<Object>;
+/**
+ * Removes unwanted objects from an image using a mask or the alpha channel.
+ *
+ * The mask can be provided explicitly or derived from the alpha channel of the input image.
+ *
+ * **Constraints**:
+ * - Image: 64px–9,437,184 total pixels.
+ * - Cost: 5 credits.
+ *
+ * @async
+ * @function editErase
+ * @param {string|Buffer|Blob} imageInput - Image to edit.
+ * @param {Object} [options={}] - Optional parameters.
+ * @param {string|Buffer|Blob} [options.mask] - Optional mask image.
+ * @param {number} [options.grow_mask=5] - Grow mask edges by this many pixels.
+ * @param {number} [options.seed=0]
+ * @param {string} [options.output_format='png']
+ * @returns {Promise<Object>} Result with edited image.
+ */
+export function editErase(imageInput: string | Buffer | Blob, options?: {
+    mask?: string | Buffer | Blob;
+    grow_mask?: number | undefined;
+    seed?: number | undefined;
+    output_format?: string | undefined;
+}): Promise<Object>;
+/**
+ * Intelligently modifies images by filling or replacing areas based on a mask or search prompt.
+ *
+ * Supports two modes:
+ * - `mask` mode: Provide explicit `mask` or use alpha channel.
+ * - `search` mode: Provide `search_prompt` for automatic object segmentation.
+ *
+ * **Constraints**:
+ * - Image: 64px–9,437,184 total pixels.
+ * - Cost: 5 credits.
+ *
+ * @async
+ * @function editInpaint
+ * @param {string|Buffer|Blob} imageInput - Base image.
+ * @param {string} prompt - What the replaced area should become.
+ * @param {Object} [options={}] - Optional: negative_prompt, seed, output_format, style_preset, grow_mask, mask, mode, search_prompt.
+ * @returns {Promise<Object>} Result with edited image.
+ */
+export function editInpaint(imageInput: string | Buffer | Blob, prompt: string, options?: Object): Promise<Object>;
+/**
+ * Expands an image by adding content in any direction (left, right, up, down).
+ *
+ * At least one direction must be non-zero.
+ *
+ * **Constraints**:
+ * - Image: 64px–9,437,184 total pixels, aspect ratio 1:2.5–2.5:1.
+ * - Cost: 4 credits.
+ *
+ * @async
+ * @function editOutpaint
+ * @param {string|Buffer|Blob} imageInput - Image to expand.
+ * @param {Object} [options={}] - Direction values in pixels (0–2000).
+ * @param {number} [options.left=0]
+ * @param {number} [options.right=0]
+ * @param {number} [options.up=0]
+ * @param {number} [options.down=0]
+ * @param {string} [options.prompt]
+ * @param {number} [options.creativity=0.5]
+ * @param {string} [options.style_preset]
+ * @returns {Promise<Object>} Result with expanded image.
+ */
+export function editOutpaint(imageInput: string | Buffer | Blob, options?: {
+    left?: number | undefined;
+    right?: number | undefined;
+    up?: number | undefined;
+    down?: number | undefined;
+    prompt?: string | undefined;
+    creativity?: number | undefined;
+    style_preset?: string | undefined;
+}): Promise<Object>;
+/**
+ * Automatically segments an object described by `search_prompt` and replaces it with new content from `prompt`.
+ *
+ * **Constraints**:
+ * - Image: 64px–9,437,184 total pixels.
+ * - Cost: 5 credits.
+ *
+ * @async
+ * @function editSearchAndReplace
+ * @param {string|Buffer|Blob} imageInput - Base image.
+ * @param {string} prompt - What to replace the object with.
+ * @param {string} search_prompt - Short description of the object to find.
+ * @param {Object} [options={}] - Optional: negative_prompt, seed, output_format, style_preset, grow_mask.
+ * @returns {Promise<Object>} Result with edited image.
+ */
+export function editSearchAndReplace(imageInput: string | Buffer | Blob, prompt: string, search_prompt: string, options?: Object): Promise<Object>;
+/**
+ * Automatically segments an object and recolors it according to the prompt.
+ *
+ * @async
+ * @function editSearchAndRecolor
+ * @param {string|Buffer|Blob} imageInput - Base image.
+ * @param {string} prompt - Desired new color description.
+ * @param {string} select_prompt - Short description of the object to recolor.
+ * @param {Object} [options={}] - Optional parameters.
+ * @returns {Promise<Object>} Result with recolored image.
+ */
+export function editSearchAndRecolor(imageInput: string | Buffer | Blob, prompt: string, select_prompt: string, options?: Object): Promise<Object>;
+/**
+ * Accurately segments the foreground and removes the background.
+ *
+ * @async
+ * @function editRemoveBackground
+ * @param {string|Buffer|Blob} imageInput - Image to process.
+ * @param {Object} [options={}] - Optional: output_format ('png' or 'webp').
+ * @returns {Promise<Object>} Result with background removed.
+ */
+export function editRemoveBackground(imageInput: string | Buffer | Blob, options?: Object): Promise<Object>;
+/**
+ * Replaces the background and adjusts lighting to match the subject.
+ *
+ * Async endpoint — returns a generation ID for polling.
+ *
+ * @async
+ * @function editReplaceBackgroundAndRelight
+ * @param {string|Buffer|Blob} subjectImage - Main subject image.
+ * @param {Object} [options={}] - Optional parameters.
+ * @returns {Promise<string|Object>} Generation ID or processed result.
+ */
+export function editReplaceBackgroundAndRelight(subjectImage: string | Buffer | Blob, options?: Object): Promise<string | Object>;
+/**
+ * Manually fetches or checks the status of an image generation using its ID.
+ *
+ * @async
+ * @function fetchImageResult
+ * @param {string} id - Generation ID.
+ * @param {string} [acceptHeader='image/*'] - `'image/*'` or `'application/json'`.
+ * @returns {Promise<Object>} Completed result or `{ status: 'in-progress', id }`.
+ */
+export function fetchImageResult(id: string, acceptHeader?: string): Promise<Object>;

package/types/API/stability.ai/index.d.ts

@@ -0,0 +1,11 @@
+declare namespace _default {
+    export { music };
+    export { musicToolset };
+    export { image };
+    export { imageToolset };
+}
+export default _default;
+import * as music from './audio.js';
+import musicToolset from './MusicToolset.js';
+import * as image from './image.js';
+import imageToolset from './ImageToolset.js';

package/types/API/x.ai/ImageToolset.d.ts

@@ -0,0 +1,3 @@
+export default tools;
+declare const tools: ToolSet;
+import ToolSet from '../../ToolSet.js';