export { FileUpload, FileUploadProps, useUpload } from './file-upload.cjs';
import { S as Stack0HandlerOptions, U as UploadHandler } from './types-BIWM_wyY.cjs';
export { a as UploadConfig, b as UploadFile, c as UploadStatus } from './types-BIWM_wyY.cjs';
export { AvatarUpload, AvatarUploadProps } from './avatar-upload.cjs';
export { LogoUpload, LogoUploadProps } from './logo-upload.cjs';
export { GalleryImage, ImageGallery, ImageGalleryProps } from './image-gallery.cjs';
export { Image, ImageProps, ImageTransformOptions, buildTransformQuery, createStack0Loader } from './image.cjs';
import * as react_jsx_runtime from 'react/jsx-runtime';
import * as class_variance_authority_types from 'class-variance-authority/types';
import { VariantProps } from 'class-variance-authority';
import * as React from 'react';
import { ClassValue } from 'clsx';
import 'next/image';

/**
 * Types for the Integrations Connect component
 */
type ConnectorCategory = "crm" | "storage" | "communication" | "productivity";
interface ConnectorInfo {
    slug: string;
    name: string;
    description?: string;
    category: ConnectorCategory;
    iconUrl?: string;
}
interface ConnectionInfo {
    id: string;
    connectorSlug: string;
    name?: string;
    status: "pending" | "connected" | "error" | "disconnected";
    externalAccountName?: string;
    createdAt: Date;
}
interface IntegrationsConnectConfig {
    /**
     * API key for authenticating with Stack0
     */
    apiKey: string;
    /**
     * Base URL for the Stack0 API
     * @default "https://api.stack0.dev/v1"
     */
    baseUrl?: string;
    /**
     * Filter connectors by category
     */
    category?: ConnectorCategory;
    /**
     * Specific connector slugs to show (e.g., ["hubspot", "salesforce"])
     */
    connectors?: string[];
    /**
     * Called when a connection is successfully created
     */
    onConnected?: (connection: ConnectionInfo) => void;
    /**
     * Called when a connection fails
     */
    onConnectionError?: (error: Error, connectorSlug: string) => void;
    /**
     * Called when a connection is disconnected
     */
    onDisconnected?: (connectionId: string) => void;
}
interface IntegrationsConnectState {
    connectors: ConnectorInfo[];
    connections: ConnectionInfo[];
    isLoading: boolean;
    error: string | null;
}

declare const containerVariants: (props?: ({
    variant?: "default" | "minimal" | null | undefined;
    size?: "default" | "sm" | "lg" | null | undefined;
} & class_variance_authority_types.ClassProp) | undefined) => string;
interface IntegrationsConnectProps extends Omit<React.HTMLAttributes<HTMLDivElement>, "onChange">, VariantProps<typeof containerVariants>, IntegrationsConnectConfig {
    /**
     * Title for the component
     * @default "Connect your apps"
     */
    title?: string;
    /**
     * Description text
     */
    description?: string;
    /**
     * Show category filter tabs
     * @default false
     */
    showCategoryFilter?: boolean;
    /**
     * Show connected integrations count
     * @default true
     */
    showConnectionCount?: boolean;
    /**
     * Whether to group connectors by category
     * @default false
     */
    groupByCategory?: boolean;
    /**
     * Custom empty state content
     */
    emptyState?: React.ReactNode;
}
declare function IntegrationsConnect({ apiKey, baseUrl, category: initialCategory, connectors: connectorFilter, onConnected, onConnectionError, onDisconnected, title, description, showCategoryFilter, showConnectionCount, groupByCategory, emptyState, className, variant, size, ...props }: IntegrationsConnectProps): react_jsx_runtime.JSX.Element;
declare namespace IntegrationsConnect {
    var displayName: string;
}

interface UseIntegrationsOptions extends IntegrationsConnectConfig {
}
interface UseIntegrationsReturn extends IntegrationsConnectState {
    connect: (connectorSlug: string, options?: {
        name?: string;
    }) => Promise<void>;
    disconnect: (connectionId: string) => Promise<void>;
    refresh: () => Promise<void>;
}
declare function useIntegrations(options: UseIntegrationsOptions): UseIntegrationsReturn;

declare function cn(...inputs: ClassValue[]): string;
declare function formatBytes(bytes: number): string;
declare function getFileExtension(filename: string): string;
declare function isImageFile(mimeType: string): boolean;
declare function isVideoFile(mimeType: string): boolean;
declare function generateId(): string;

/**
 * Creates an upload handler that calls your API endpoint
 *
 * Your server endpoint should use the Stack0 SDK to create presigned URLs.
 * The client uploads directly to S3 using the presigned URL.
 *
 * @example
 * ```tsx
 * // Client-side usage
 * import { FileUpload, createStack0Handler } from "@stack0/elements";
 *
 * const handler = createStack0Handler({
 *   endpoint: "/api/upload",
 * });
 *
 * <FileUpload handler={handler} />
 * ```
 *
 * @example
 * ```ts
 * // Server-side API route (Next.js App Router)
 * // app/api/upload/route.ts
 * import { stack0 } from "@stack0/sdk";
 *
 * export async function POST(request: Request) {
 *   const { filename, mimeType, size, folder } = await request.json();
 *
 *   const result = await stack0.cdn.createUpload({
 *     filename,
 *     mimeType,
 *     size,
 *     folder,
 *     public: true, // Creates a public presigned URL
 *   });
 *
 *   return Response.json({
 *     uploadUrl: result.uploadUrl,
 *     assetId: result.assetId,
 *   });
 * }
 * ```
 */
declare function createStack0Handler(options: Stack0HandlerOptions): UploadHandler;

export { type ConnectionInfo, type ConnectorCategory, type ConnectorInfo, IntegrationsConnect, type IntegrationsConnectConfig, type IntegrationsConnectProps, type IntegrationsConnectState, Stack0HandlerOptions, UploadHandler, cn, createStack0Handler, formatBytes, generateId, getFileExtension, isImageFile, isVideoFile, useIntegrations };