@oomol-lab/open-connector 1.9.1 → 1.9.3

package/src/providers/lusha/runtime.js

@@ -1,5 +1,5 @@
 import { compactObject, optionalRecord } from "../../core/cast.js";
-import { ProviderRequestError, providerUserAgent } from "../provider-runtime.js";
+import { ProviderRequestError, providerUserAgent, providerInputError, providerResponseError, } from "../provider-runtime.js";
 export const lushaApiBaseUrl = "https://api.lusha.com";
 export const lushaActionHandlers = {
     get_account_usage(_input, context) {
@@ -125,7 +125,7 @@ function mapLushaError(status, message, phase) {
         return new ProviderRequestError(phase === "validate" ? 400 : 401, message);
     }
     if (status >= 400 && status < 500) {
-        return new ProviderRequestError(400, message);
+        return providerInputError(message);
     }
-    return new ProviderRequestError(502, message);
+    return providerResponseError(message);
 }

package/src/providers/magichour/actions.d.ts

@@ -0,0 +1,22 @@
+import type { ActionDefinition, JsonSchema } from "../../core/types.ts";
+export interface MagicHourRoute {
+    path: string;
+    method: string;
+    parameters: Array<{
+        name: string;
+        in: string;
+    }>;
+    body: boolean;
+}
+interface MagicHourDefinition {
+    name: string;
+    description: string;
+    operationType: ActionDefinition["operationType"];
+    route: MagicHourRoute;
+    inputSchema: JsonSchema;
+    outputSchema: JsonSchema;
+}
+declare const definitions: MagicHourDefinition[];
+export declare const magicHourRoutes: Map<string, (typeof definitions)[number]["route"]>;
+export declare const magicHourActions: ActionDefinition[];
+export {};

package/src/providers/magichour/actions.js

@@ -0,0 +1,308 @@
+import { defineProviderAction } from "../../core/provider-definition.js";
+import { audioInputSchemas } from "./audio-schemas.js";
+import { imageInputSchemas } from "./image-schemas.js";
+import { projectSubmissionSchema, projectInputSchema, videoProjectSchema, imageProjectSchema, audioProjectSchema, deletedProjectSchema, } from "./project-schemas.js";
+import { accountInputSchema, accountOutputSchema, savedItemsInputSchema, savedItemsOutputSchema, faceDetectionInputSchema, faceDetectionOutputSchema, faceDetectionResultInputSchema, faceDetectionResultOutputSchema, uploadAssetInputSchema, uploadAssetOutputSchema, } from "./utility-schemas.js";
+import { videoInputSchemas } from "./video-schemas.js";
+const actionLifecycles = {
+    create_face_detection: {
+        startActionId: "magichour.create_face_detection",
+        statusActionId: "magichour.get_face_detection",
+    },
+    create_ai_talking_photo: {
+        startActionId: "magichour.create_ai_talking_photo",
+        statusActionId: "magichour.get_video_projects",
+    },
+    create_ai_ugc_ad: { startActionId: "magichour.create_ai_ugc_ad", statusActionId: "magichour.get_video_projects" },
+    create_ai_video_editor: {
+        startActionId: "magichour.create_ai_video_editor",
+        statusActionId: "magichour.get_video_projects",
+    },
+    create_ai_video_translator: {
+        startActionId: "magichour.create_ai_video_translator",
+        statusActionId: "magichour.get_video_projects",
+    },
+    create_ai_video_upscaler: {
+        startActionId: "magichour.create_ai_video_upscaler",
+        statusActionId: "magichour.get_video_projects",
+    },
+    create_animation: { startActionId: "magichour.create_animation", statusActionId: "magichour.get_video_projects" },
+    create_audio_to_video: {
+        startActionId: "magichour.create_audio_to_video",
+        statusActionId: "magichour.get_video_projects",
+    },
+    create_auto_subtitle_generator: {
+        startActionId: "magichour.create_auto_subtitle_generator",
+        statusActionId: "magichour.get_video_projects",
+    },
+    create_character_replace: {
+        startActionId: "magichour.create_character_replace",
+        statusActionId: "magichour.get_video_projects",
+    },
+    create_face_swap: { startActionId: "magichour.create_face_swap", statusActionId: "magichour.get_video_projects" },
+    create_image_to_video: {
+        startActionId: "magichour.create_image_to_video",
+        statusActionId: "magichour.get_video_projects",
+    },
+    create_lip_sync: { startActionId: "magichour.create_lip_sync", statusActionId: "magichour.get_video_projects" },
+    create_text_to_video: {
+        startActionId: "magichour.create_text_to_video",
+        statusActionId: "magichour.get_video_projects",
+    },
+    create_video_to_video: {
+        startActionId: "magichour.create_video_to_video",
+        statusActionId: "magichour.get_video_projects",
+    },
+    create_ai_clothes_changer: {
+        startActionId: "magichour.create_ai_clothes_changer",
+        statusActionId: "magichour.get_image_projects",
+    },
+    create_ai_face_editor: {
+        startActionId: "magichour.create_ai_face_editor",
+        statusActionId: "magichour.get_image_projects",
+    },
+    create_ai_gif_generator: {
+        startActionId: "magichour.create_ai_gif_generator",
+        statusActionId: "magichour.get_image_projects",
+    },
+    create_ai_image_editor: {
+        startActionId: "magichour.create_ai_image_editor",
+        statusActionId: "magichour.get_image_projects",
+    },
+    create_ai_headshot_generator: {
+        startActionId: "magichour.create_ai_headshot_generator",
+        statusActionId: "magichour.get_image_projects",
+    },
+    create_ai_image_generator: {
+        startActionId: "magichour.create_ai_image_generator",
+        statusActionId: "magichour.get_image_projects",
+    },
+    create_ai_image_upscaler: {
+        startActionId: "magichour.create_ai_image_upscaler",
+        statusActionId: "magichour.get_image_projects",
+    },
+    create_ai_meme_generator: {
+        startActionId: "magichour.create_ai_meme_generator",
+        statusActionId: "magichour.get_image_projects",
+    },
+    create_ai_qr_code_generator: {
+        startActionId: "magichour.create_ai_qr_code_generator",
+        statusActionId: "magichour.get_image_projects",
+    },
+    create_body_swap: { startActionId: "magichour.create_body_swap", statusActionId: "magichour.get_image_projects" },
+    create_face_swap_photo: {
+        startActionId: "magichour.create_face_swap_photo",
+        statusActionId: "magichour.get_image_projects",
+    },
+    create_head_swap: { startActionId: "magichour.create_head_swap", statusActionId: "magichour.get_image_projects" },
+    create_image_background_remover: {
+        startActionId: "magichour.create_image_background_remover",
+        statusActionId: "magichour.get_image_projects",
+    },
+    create_photo_colorizer: {
+        startActionId: "magichour.create_photo_colorizer",
+        statusActionId: "magichour.get_image_projects",
+    },
+    create_ai_music_generator: {
+        startActionId: "magichour.create_ai_music_generator",
+        statusActionId: "magichour.get_audio_projects",
+    },
+    create_ai_voice_cloner: {
+        startActionId: "magichour.create_ai_voice_cloner",
+        statusActionId: "magichour.get_audio_projects",
+    },
+    create_ai_voice_generator: {
+        startActionId: "magichour.create_ai_voice_generator",
+        statusActionId: "magichour.get_audio_projects",
+    },
+};
+function mediaAction(name, title, kind, inputSchema) {
+    return {
+        name,
+        description: `${title} Submit the asynchronous task and use the linked result action to retrieve completion and downloads.`,
+        operationType: "write",
+        route: {
+            path: `/v1/${name.slice("create_".length).replaceAll("_", "-")}`,
+            method: "POST",
+            parameters: [],
+            body: true,
+        },
+        inputSchema,
+        outputSchema: projectSubmissionSchema(kind),
+    };
+}
+const definitions = [
+    {
+        name: "get_account",
+        description: "Get account details.",
+        operationType: "read",
+        route: { path: "/v1/account", method: "GET", parameters: [], body: false },
+        inputSchema: accountInputSchema,
+        outputSchema: accountOutputSchema,
+    },
+    {
+        name: "list_saved_items",
+        description: "List saved items.",
+        operationType: "read",
+        route: {
+            path: "/v1/saved-items",
+            method: "GET",
+            parameters: [
+                { name: "type", in: "query" },
+                { name: "limit", in: "query" },
+                { name: "cursor", in: "query" },
+            ],
+            body: false,
+        },
+        inputSchema: savedItemsInputSchema,
+        outputSchema: savedItemsOutputSchema,
+    },
+    {
+        name: "get_face_detection",
+        description: "Get face detection details.",
+        operationType: "read",
+        route: {
+            path: "/v1/face-detection/{id}",
+            method: "GET",
+            parameters: [{ name: "id", in: "path" }],
+            body: false,
+        },
+        inputSchema: faceDetectionResultInputSchema,
+        outputSchema: faceDetectionResultOutputSchema,
+    },
+    {
+        name: "create_face_detection",
+        description: "Face Detection. Submit the asynchronous task and use the linked result action to retrieve completion and downloads.",
+        operationType: "write",
+        route: { path: "/v1/face-detection", method: "POST", parameters: [], body: true },
+        inputSchema: faceDetectionInputSchema,
+        outputSchema: faceDetectionOutputSchema,
+    },
+    {
+        name: "get_video_projects",
+        description: "Get video details.",
+        operationType: "read",
+        route: {
+            path: "/v1/video-projects/{id}",
+            method: "GET",
+            parameters: [{ name: "id", in: "path" }],
+            body: false,
+        },
+        inputSchema: projectInputSchema("video", "Get video details parameters."),
+        outputSchema: videoProjectSchema,
+    },
+    {
+        name: "delete_video_projects",
+        description: "Delete video.",
+        operationType: "destructive",
+        route: {
+            path: "/v1/video-projects/{id}",
+            method: "DELETE",
+            parameters: [{ name: "id", in: "path" }],
+            body: false,
+        },
+        inputSchema: projectInputSchema("video", "Delete video parameters."),
+        outputSchema: deletedProjectSchema,
+    },
+    mediaAction("create_ai_talking_photo", "AI Talking Photo.", "video", videoInputSchemas.create_ai_talking_photo),
+    mediaAction("create_ai_ugc_ad", "AI UGC Ad Generator.", "video", videoInputSchemas.create_ai_ugc_ad),
+    mediaAction("create_ai_video_editor", "AI Video Editor.", "video", videoInputSchemas.create_ai_video_editor),
+    mediaAction("create_ai_video_translator", "AI Video Translator.", "video", videoInputSchemas.create_ai_video_translator),
+    mediaAction("create_ai_video_upscaler", "AI Video Upscaler.", "video", videoInputSchemas.create_ai_video_upscaler),
+    mediaAction("create_animation", "Animation.", "video", videoInputSchemas.create_animation),
+    mediaAction("create_audio_to_video", "Audio-to-Video.", "video", videoInputSchemas.create_audio_to_video),
+    mediaAction("create_auto_subtitle_generator", "Auto Subtitle Generator.", "video", videoInputSchemas.create_auto_subtitle_generator),
+    mediaAction("create_character_replace", "Character Replace.", "video", videoInputSchemas.create_character_replace),
+    mediaAction("create_face_swap", "Face Swap Video.", "video", videoInputSchemas.create_face_swap),
+    mediaAction("create_image_to_video", "Image-to-Video.", "video", videoInputSchemas.create_image_to_video),
+    mediaAction("create_lip_sync", "Lip Sync.", "video", videoInputSchemas.create_lip_sync),
+    mediaAction("create_text_to_video", "Text-to-Video.", "video", videoInputSchemas.create_text_to_video),
+    mediaAction("create_video_to_video", "Video-to-Video.", "video", videoInputSchemas.create_video_to_video),
+    {
+        name: "get_image_projects",
+        description: "Get image details.",
+        operationType: "read",
+        route: {
+            path: "/v1/image-projects/{id}",
+            method: "GET",
+            parameters: [{ name: "id", in: "path" }],
+            body: false,
+        },
+        inputSchema: projectInputSchema("image", "Get image details parameters."),
+        outputSchema: imageProjectSchema,
+    },
+    {
+        name: "delete_image_projects",
+        description: "Delete image.",
+        operationType: "destructive",
+        route: {
+            path: "/v1/image-projects/{id}",
+            method: "DELETE",
+            parameters: [{ name: "id", in: "path" }],
+            body: false,
+        },
+        inputSchema: projectInputSchema("image", "Delete image parameters."),
+        outputSchema: deletedProjectSchema,
+    },
+    mediaAction("create_ai_clothes_changer", "AI Clothes Changer.", "image", imageInputSchemas.create_ai_clothes_changer),
+    mediaAction("create_ai_face_editor", "AI Face Editor.", "image", imageInputSchemas.create_ai_face_editor),
+    mediaAction("create_ai_gif_generator", "AI GIF Generator.", "image", imageInputSchemas.create_ai_gif_generator),
+    mediaAction("create_ai_image_editor", "AI Image Editor.", "image", imageInputSchemas.create_ai_image_editor),
+    mediaAction("create_ai_headshot_generator", "AI Headshot Generator.", "image", imageInputSchemas.create_ai_headshot_generator),
+    mediaAction("create_ai_image_generator", "AI Image Generator.", "image", imageInputSchemas.create_ai_image_generator),
+    mediaAction("create_ai_image_upscaler", "AI Image Upscaler.", "image", imageInputSchemas.create_ai_image_upscaler),
+    mediaAction("create_ai_meme_generator", "AI Meme Generator.", "image", imageInputSchemas.create_ai_meme_generator),
+    mediaAction("create_ai_qr_code_generator", "AI QR Code Generator.", "image", imageInputSchemas.create_ai_qr_code_generator),
+    mediaAction("create_body_swap", "Body Swap.", "image", imageInputSchemas.create_body_swap),
+    mediaAction("create_face_swap_photo", "Face Swap Photo.", "image", imageInputSchemas.create_face_swap_photo),
+    mediaAction("create_head_swap", "Head Swap.", "image", imageInputSchemas.create_head_swap),
+    mediaAction("create_image_background_remover", "Image Background Remover.", "image", imageInputSchemas.create_image_background_remover),
+    mediaAction("create_photo_colorizer", "Photo Colorizer.", "image", imageInputSchemas.create_photo_colorizer),
+    {
+        name: "get_audio_projects",
+        description: "Get audio details.",
+        operationType: "read",
+        route: {
+            path: "/v1/audio-projects/{id}",
+            method: "GET",
+            parameters: [{ name: "id", in: "path" }],
+            body: false,
+        },
+        inputSchema: projectInputSchema("audio", "Get audio details parameters."),
+        outputSchema: audioProjectSchema,
+    },
+    {
+        name: "delete_audio_projects",
+        description: "Delete audio.",
+        operationType: "destructive",
+        route: {
+            path: "/v1/audio-projects/{id}",
+            method: "DELETE",
+            parameters: [{ name: "id", in: "path" }],
+            body: false,
+        },
+        inputSchema: projectInputSchema("audio", "Delete audio parameters."),
+        outputSchema: deletedProjectSchema,
+    },
+    mediaAction("create_ai_music_generator", "AI Music Generator.", "audio", audioInputSchemas.create_ai_music_generator),
+    mediaAction("create_ai_voice_cloner", "AI Voice Cloner.", "audio", audioInputSchemas.create_ai_voice_cloner),
+    mediaAction("create_ai_voice_generator", "AI Voice Generator.", "audio", audioInputSchemas.create_ai_voice_generator),
+    {
+        name: "upload_asset",
+        description: "Upload an asset from a public URL to Magic Hour storage and return its reusable file_path. Maximum 20 MiB; larger hosted files can be passed directly to generation actions.",
+        operationType: "write",
+        route: { path: "/v1/files/upload-urls", method: "POST", parameters: [], body: true },
+        inputSchema: uploadAssetInputSchema,
+        outputSchema: uploadAssetOutputSchema,
+    },
+];
+export const magicHourRoutes = new Map(definitions.map((definition) => [definition.name, definition.route]));
+export const magicHourActions = definitions.map((definition) => defineProviderAction("magichour", {
+    name: definition.name,
+    description: definition.description,
+    operationType: definition.operationType,
+    requiredScopes: [],
+    inputSchema: definition.inputSchema,
+    outputSchema: definition.outputSchema,
+    asyncLifecycle: actionLifecycles[definition.name],
+}));

package/src/providers/magichour/audio-schemas.d.ts

@@ -0,0 +1,2 @@
+import type { JsonSchema } from "../../core/types.ts";
+export declare const audioInputSchemas: Record<string, JsonSchema>;

package/src/providers/magichour/audio-schemas.js

@@ -0,0 +1,54 @@
+import { s } from "../../core/json-schema.js";
+import { audioNameSchema, assetPathSchema } from "./shared-schemas.js";
+import { magicHourVoiceNames } from "./voices.js";
+const voiceSchema = s.stringEnum("The voice used to generate speech. Select a value from the supported voice names.", magicHourVoiceNames);
+const aiMusicGeneratorInputSchema = s.object("AI Music Generator parameters.", {
+    name: audioNameSchema,
+    duration: s.integer("Requested track duration in seconds, from 15 to 300. Determines credits charged.", {
+        minimum: 15,
+        maximum: 300,
+    }),
+    style: s.object("Style.", {
+        prompt: s.string("Describe the song, including genre, mood, and instruments.", {
+            minLength: 1,
+        }),
+        instrumental: s.boolean("Generate music without vocals. When true, lyrics is ignored."),
+        lyrics: s.string("Custom lyrics. Omit or leave blank for AI-generated lyrics when instrumental is false."),
+    }, { required: ["prompt"] }),
+}, { required: ["duration", "style"] });
+const aiVoiceClonerInputSchema = s.object("AI Voice Cloner parameters.", {
+    name: audioNameSchema,
+    assets: s.object("Provide the assets for voice cloning.", { audio_file_path: assetPathSchema("The audio used to clone the voice.", true) }, {
+        required: ["audio_file_path"],
+        additionalProperties: true,
+    }),
+    style: s.object("Style.", {
+        prompt: s.string("Text used to generate speech from the cloned voice. The character limit is 1000 characters.", { minLength: 1, maxLength: 1000 }),
+    }, {
+        required: ["prompt"],
+        additionalProperties: true,
+    }),
+}, {
+    required: ["assets", "style"],
+    additionalProperties: true,
+});
+const aiVoiceGeneratorInputSchema = s.object("AI Voice Generator parameters.", {
+    name: audioNameSchema,
+    style: s.object("The content used to generate speech.", {
+        prompt: s.string("Text used to generate speech. The character limit is 1000 characters.", {
+            minLength: 1,
+        }),
+        voice_name: voiceSchema,
+    }, {
+        required: ["prompt", "voice_name"],
+        additionalProperties: true,
+    }),
+}, {
+    required: ["style"],
+    additionalProperties: true,
+});
+export const audioInputSchemas = {
+    create_ai_music_generator: aiMusicGeneratorInputSchema,
+    create_ai_voice_cloner: aiVoiceClonerInputSchema,
+    create_ai_voice_generator: aiVoiceGeneratorInputSchema,
+};

package/src/providers/magichour/executors.d.ts

@@ -0,0 +1,4 @@
+import type { CredentialValidators, ProviderExecutors, ProviderProxyExecutor } from "../../core/types.ts";
+export declare const credentialValidators: CredentialValidators;
+export declare const executors: ProviderExecutors;
+export declare const proxy: ProviderProxyExecutor;

package/src/providers/magichour/executors.js

@@ -0,0 +1,115 @@
+import { optionalRecord, optionalString, looseArray } from "../../core/cast.js";
+import { createProviderFetch } from "../provider-runtime.js";
+import { downloadUploadSource, requiredResponseRecord, requiredInputString, runProviderRequest, isAbortLikeError, providerUserAgent, ProviderRequestError, providerInputError, providerResponseError, defineApiKeyProviderExecutors, defineProviderProxy, } from "../provider-runtime.js";
+import { magicHourActions } from "./actions.js";
+import { magicHourRoutes } from "./actions.js";
+const baseUrl = "https://api.magichour.ai";
+async function requestMagicHour(url, method, apiKey, body, fetcher, validation = false, parentSignal) {
+    return runProviderRequest({ label: "Magic Hour", signal: parentSignal }, async (signal) => {
+        const response = await fetcher(url, {
+            method,
+            headers: {
+                authorization: `Bearer ${apiKey}`,
+                accept: "application/json",
+                "content-type": "application/json",
+                "user-agent": providerUserAgent,
+            },
+            body: body === undefined ? undefined : JSON.stringify(body),
+            signal,
+        });
+        if (response.status === 204 && response.ok)
+            return { deleted: true };
+        let payload;
+        try {
+            payload = await response.json();
+        }
+        catch (error) {
+            if (isAbortLikeError(error))
+                throw error;
+            throw new ProviderRequestError(response.ok ? 502 : response.status, response.ok ? "Magic Hour returned invalid JSON" : `Magic Hour request failed (HTTP ${response.status})`, undefined, "provider_error");
+        }
+        if (!response.ok) {
+            const error = optionalRecord(payload);
+            const code = optionalString(error?.code);
+            const message = optionalString(error?.message) ?? `Magic Hour request failed (HTTP ${response.status})`;
+            throw new ProviderRequestError(code === "unauthorized" && validation ? 400 : response.status, code ? `${code}: ${message}` : message, undefined, code === "unauthorized" ? (validation ? "invalid_input" : "authorization_failed") : "provider_error");
+        }
+        return requiredResponseRecord(payload, "Magic Hour response");
+    });
+}
+async function uploadAsset(values, apiKey, fetcher, parentSignal) {
+    return runProviderRequest({ label: "Magic Hour asset upload", timeoutMs: 120000, signal: parentSignal }, async (signal) => {
+        const source = await downloadUploadSource({
+            url: requiredInputString(values.fileUrl, "fileUrl"),
+            fieldName: "fileUrl",
+            fetcher,
+            signal,
+        });
+        const result = await requestMagicHour(new URL("/v1/files/upload-urls", baseUrl), "POST", apiKey, { items: [{ type: values.type, extension: values.extension }] }, fetcher, undefined, signal);
+        const item = optionalRecord(looseArray(result.items)[0]);
+        const uploadUrl = optionalString(item?.upload_url);
+        const filePath = optionalString(item?.file_path);
+        if (!uploadUrl || !filePath)
+            throw providerResponseError("Magic Hour upload response is missing upload_url or file_path");
+        const uploadFetch = createProviderFetch({ fetch: fetcher });
+        const response = await uploadFetch(uploadUrl, {
+            method: "PUT",
+            headers: { "content-type": source.contentType ?? "application/octet-stream" },
+            body: new Uint8Array(source.bytes),
+            signal,
+        });
+        await response.body?.cancel();
+        if (!response.ok)
+            throw new ProviderRequestError(response.status, `Magic Hour asset upload failed (HTTP ${response.status})`, undefined, "provider_error");
+        return { file_path: filePath };
+    });
+}
+async function execute(actionName, values, context) {
+    const { apiKey, fetcher } = context;
+    const route = magicHourRoutes.get(actionName);
+    if (actionName === "upload_asset")
+        return uploadAsset(values, apiKey, fetcher, context.signal);
+    if (!route)
+        throw providerInputError("Unknown action route");
+    let pathname = route.path;
+    const query = new URLSearchParams();
+    for (const parameter of route.parameters) {
+        const value = values[parameter.name];
+        if (value === undefined || value === null)
+            continue;
+        if (parameter.in === "path") {
+            const segment = String(value);
+            if (segment === "." || segment === "..")
+                throw providerInputError(`${parameter.name} must not be a dot path segment`);
+            pathname = pathname.replace(`{${parameter.name}}`, encodeURIComponent(segment));
+        }
+        else
+            query.set(parameter.name, String(value));
+    }
+    const url = new URL(pathname, baseUrl);
+    url.search = query.toString();
+    return requestMagicHour(url, route.method, apiKey, route.body ? values : undefined, fetcher, undefined, context.signal);
+}
+export const credentialValidators = {
+    async apiKey(input, { fetcher, signal }) {
+        const result = await requestMagicHour(new URL("/v1/account", baseUrl), "GET", input.apiKey, undefined, fetcher, true, signal);
+        return {
+            profile: { displayName: optionalString(result.email) ?? "Magic Hour Account" },
+            grantedScopes: [],
+            metadata: {
+                accountId: optionalString(result.id),
+                validationEndpoint: "/v1/account",
+            },
+        };
+    },
+};
+export const executors = defineApiKeyProviderExecutors("magichour", Object.fromEntries(magicHourActions.map((action) => [action.name, (values, context) => execute(action.name, values, context)])));
+export const proxy = defineProviderProxy({
+    service: "magichour",
+    baseUrl: baseUrl,
+    auth: { type: "api_key_authorization", prefix: "Bearer " },
+    customizeRequest({ headers }) {
+        headers.set("accept", "application/json");
+        headers.set("user-agent", providerUserAgent);
+    },
+});

package/src/providers/magichour/image-schemas.d.ts

@@ -0,0 +1,2 @@
+import type { JsonSchema } from "../../core/types.ts";
+export declare const imageInputSchemas: Record<string, JsonSchema>;