the-pet-loft/convex/_generated/api.d.ts

/* eslint-disable */
/**
 * Generated `api` utility.
 *
 * THIS CODE IS AUTOMATICALLY GENERATED.
 *
 * To regenerate, run `npx convex dev`.
 * @module
 */

import type * as addresses from "../addresses.js";
import type * as adminInvitations from "../adminInvitations.js";
import type * as carts from "../carts.js";
import type * as categories from "../categories.js";
import type * as checkout from "../checkout.js";
import type * as checkoutActions from "../checkoutActions.js";
import type * as emails from "../emails.js";
import type * as fulfillmentActions from "../fulfillmentActions.js";
import type * as http from "../http.js";
import type * as model_carts from "../model/carts.js";
import type * as model_categories from "../model/categories.js";
import type * as model_checkout from "../model/checkout.js";
import type * as model_orders from "../model/orders.js";
import type * as model_products from "../model/products.js";
import type * as model_shippo from "../model/shippo.js";
import type * as model_stripe from "../model/stripe.js";
import type * as model_users from "../model/users.js";
import type * as orders from "../orders.js";
import type * as products from "../products.js";
import type * as returnActions from "../returnActions.js";
import type * as reviews from "../reviews.js";
import type * as shippoWebhook from "../shippoWebhook.js";
import type * as stripeActions from "../stripeActions.js";
import type * as users from "../users.js";
import type * as wishlists from "../wishlists.js";

import type {
  ApiFromModules,
  FilterApi,
  FunctionReference,
} from "convex/server";

declare const fullApi: ApiFromModules<{
  addresses: typeof addresses;
  adminInvitations: typeof adminInvitations;
  carts: typeof carts;
  categories: typeof categories;
  checkout: typeof checkout;
  checkoutActions: typeof checkoutActions;
  emails: typeof emails;
  fulfillmentActions: typeof fulfillmentActions;
  http: typeof http;
  "model/carts": typeof model_carts;
  "model/categories": typeof model_categories;
  "model/checkout": typeof model_checkout;
  "model/orders": typeof model_orders;
  "model/products": typeof model_products;
  "model/shippo": typeof model_shippo;
  "model/stripe": typeof model_stripe;
  "model/users": typeof model_users;
  orders: typeof orders;
  products: typeof products;
  returnActions: typeof returnActions;
  reviews: typeof reviews;
  shippoWebhook: typeof shippoWebhook;
  stripeActions: typeof stripeActions;
  users: typeof users;
  wishlists: typeof wishlists;
}>;

/**
 * A utility for referencing Convex functions in your app's public API.
 *
 * Usage:
 * ```js
 * const myFunctionReference = api.myModule.myFunction;
 * ```
 */
export declare const api: FilterApi<
  typeof fullApi,
  FunctionReference<any, "public">
>;

/**
 * A utility for referencing Convex functions in your app's internal API.
 *
 * Usage:
 * ```js
 * const myFunctionReference = internal.myModule.myFunction;
 * ```
 */
export declare const internal: FilterApi<
  typeof fullApi,
  FunctionReference<any, "internal">
>;

export declare const components: {
  resend: {
    lib: {
      cancelEmail: FunctionReference<
        "mutation",
        "internal",
        { emailId: string },
        null
      >;
      cleanupAbandonedEmails: FunctionReference<
        "mutation",
        "internal",
        { olderThan?: number },
        null
      >;
      cleanupOldEmails: FunctionReference<
        "mutation",
        "internal",
        { olderThan?: number },
        null
      >;
      createManualEmail: FunctionReference<
        "mutation",
        "internal",
        {
          from: string;
          headers?: Array<{ name: string; value: string }>;
          replyTo?: Array<string>;
          subject: string;
          to: Array<string> | string;
        },
        string
      >;
      get: FunctionReference<
        "query",
        "internal",
        { emailId: string },
        {
          bcc?: Array<string>;
          bounced?: boolean;
          cc?: Array<string>;
          clicked?: boolean;
          complained: boolean;
          createdAt: number;
          deliveryDelayed?: boolean;
          errorMessage?: string;
          failed?: boolean;
          finalizedAt: number;
          from: string;
          headers?: Array<{ name: string; value: string }>;
          html?: string;
          opened: boolean;
          replyTo: Array<string>;
          resendId?: string;
          segment: number;
          status:
            | "waiting"
            | "queued"
            | "cancelled"
            | "sent"
            | "delivered"
            | "delivery_delayed"
            | "bounced"
            | "failed";
          subject?: string;
          template?: {
            id: string;
            variables?: Record<string, string | number>;
          };
          text?: string;
          to: Array<string>;
        } | null
      >;
      getStatus: FunctionReference<
        "query",
        "internal",
        { emailId: string },
        {
          bounced: boolean;
          clicked: boolean;
          complained: boolean;
          deliveryDelayed: boolean;
          errorMessage: string | null;
          failed: boolean;
          opened: boolean;
          status:
            | "waiting"
            | "queued"
            | "cancelled"
            | "sent"
            | "delivered"
            | "delivery_delayed"
            | "bounced"
            | "failed";
        } | null
      >;
      handleEmailEvent: FunctionReference<
        "mutation",
        "internal",
        { event: any },
        null
      >;
      sendEmail: FunctionReference<
        "mutation",
        "internal",
        {
          bcc?: Array<string>;
          cc?: Array<string>;
          from: string;
          headers?: Array<{ name: string; value: string }>;
          html?: string;
          options: {
            apiKey: string;
            initialBackoffMs: number;
            onEmailEvent?: { fnHandle: string };
            retryAttempts: number;
            testMode: boolean;
          };
          replyTo?: Array<string>;
          subject?: string;
          template?: {
            id: string;
            variables?: Record<string, string | number>;
          };
          text?: string;
          to: Array<string>;
        },
        string
      >;
      updateManualEmail: FunctionReference<
        "mutation",
        "internal",
        {
          emailId: string;
          errorMessage?: string;
          resendId?: string;
          status:
            | "waiting"
            | "queued"
            | "cancelled"
            | "sent"
            | "delivered"
            | "delivery_delayed"
            | "bounced"
            | "failed";
        },
        null
      >;
    };
  };
};