base44.functions.invoke(functionName, data?): Promise<AxiosResponse>

try {
  // ⚠️ invoke() devuelve la respuesta axios SIN PROCESAR, por lo que el JSON que devolvió tu función
  //    vive en `.data` — NO en el objeto de nivel superior.
  const res = await base44.functions.invoke("process-order", { orderId });
  const result = res.data;        // ✅  por ejemplo, res.data.success
  // const result = res;          // ❌  esto es { data, status, headers, … }
} catch (err) {
  // invoke() LANZA en una respuesta no-2xx; el cuerpo del error está en err.response.data.
  console.error(err.response?.data);
}

base44.functions.fetch(path, init?): Promise<Response>

const res = await base44.functions.invoke("processOrder", {
  orderId: "order-123",
  action: "ship"
});

// invoke() resuelve a la respuesta axios sin procesar — lee el JSON de tu función en .data
const result = res.data;
console.log(result);

// Usa fetch() para respuestas en streaming (SSE, texto por trozos, etc.)
const response = await base44.functions.fetch("/stream-data", {
  method: "POST",
  headers: { "Content-Type": "application/json" },
  body: JSON.stringify({ prompt: "Tell me a story" })
});

// Leer como un stream
const reader = response.body.getReader();
const decoder = new TextDecoder();
while (true) {
  const { done, value } = await reader.read();
  if (done) break;
  console.log(decoder.decode(value));
}

// PUT, PATCH, DELETE u otros métodos
const response = await base44.functions.fetch("/my-resource/123", {
  method: "DELETE"
});
console.log(response.status); // 204

const fileInput = document.querySelector('input[type="file"]');
const file = fileInput.files[0];

// Usa automáticamente multipart/form-data cuando hay objetos File presentes
const res = await base44.functions.invoke("uploadDocument", {
  file: file,
  category: "invoices"
});
const result = res.data; // el JSON de la función está en .data

// Dentro de otra función de backend
const res = await base44.asServiceRole.functions.invoke("adminTask", {
  userId: "user-123"
});
const result = res.data; // el JSON de la función está en .data

curl -X POST "https://<app-domain>/functions/<function-name>" \
  -H "Content-Type: application/json" \
  -d '{"key": "value"}'

base44/
  functions/
    process-order/
      entry.ts

// base44/functions/process-order/entry.ts
import { createClientFromRequest } from "npm:@base44/sdk";

Deno.serve(async (req) => {
  // Obtén el cliente autenticado desde la solicitud
  const base44 = createClientFromRequest(req);
  
  // Analiza la entrada
  const { orderId, action } = await req.json();
  
  // Tu lógica aquí
  const order = await base44.entities.Orders.get(orderId);
  
  // Devuelve la respuesta
  return Response.json({
    success: true,
    order: order
  });
});

import { createClientFromRequest } from "npm:@base44/sdk";

Deno.serve(async (req) => {
  const base44 = createClientFromRequest(req);
  
  // Comprueba que el usuario está autenticado
  const user = await base44.auth.me();
  if (!user) {
    return Response.json({ error: "Unauthorized" }, { status: 401 });
  }
  
  // Usa el rol de servicio para operaciones de administrador
  const allOrders = await base44.asServiceRole.entities.Orders.list();
  
  return Response.json({ orders: allOrders });
});

Deno.serve(async (req) => {
  // Accede a las variables de entorno (configuradas en la configuración de la app)
  const apiKey = Deno.env.get("STRIPE_API_KEY");
  
  const response = await fetch("https://api.stripe.com/v1/charges", {
    headers: {
      "Authorization": `Bearer ${apiKey}`
    }
  });
  
  return Response.json(await response.json());
});

import { createClientFromRequest } from "npm:@base44/sdk";

Deno.serve(async (req) => {
  try {
    const base44 = createClientFromRequest(req);
    const { orderId } = await req.json();
    
    const order = await base44.entities.Orders.get(orderId);
    if (!order) {
      return Response.json(
        { error: "Order not found" },
        { status: 404 }
      );
    }
    
    return Response.json({ order });
    
  } catch (error) {
    return Response.json(
      { error: error.message },
      { status: 500 }
    );
  }
});

/**
 * Registro de nombres de función.
 * Aumenta esta interfaz para habilitar autocompletado para nombres de función.
 * Normalmente lo rellena el generador de tipos de la CLI de Base44.
 */
interface FunctionNameRegistry {}

/**
 * Tipo de nombre de función - usa claves del registro si está aumentado, de lo contrario string.
 */
type FunctionName = keyof FunctionNameRegistry extends never ? string : keyof FunctionNameRegistry;

/**
 * Opciones para functions.fetch(). Usa opciones de fetch nativas directamente.
 */
type FunctionsFetchInit = RequestInit;

/** Módulo Functions para invocar funciones de backend personalizadas. */
interface FunctionsModule {
  /**
   * Invoca una función de backend personalizada por nombre.
   *
   * Si algún parámetro es un objeto File, la solicitud se enviará automáticamente
   * como multipart/form-data. De lo contrario, se enviará como JSON.
   *
   * @param functionName - El nombre de la función a invocar.
   * @param data - Objeto opcional que contiene parámetros nombrados para la función.
   * @returns Promesa que resuelve a la respuesta de la función.
   */
  invoke(functionName: FunctionName, data?: Record<string, any>): Promise<any>;

  /**
   * Realiza una solicitud HTTP directa a una ruta de función de backend y devuelve el Response nativo.
   *
   * Usar para respuestas en streaming (SSE, texto por trozos), métodos HTTP personalizados,
   * o cuando necesites acceso sin procesar a la respuesta.
   *
   * @param path - Ruta de función, por ejemplo `/streaming_demo` o `/my-function/endpoint`
   * @param init - Opciones de fetch nativas opcionales.
   * @returns Promesa que resuelve a un Response de fetch nativo.
   */
  fetch(path: string, init?: FunctionsFetchInit): Promise<Response>;
}