@proveanything/smartlinks 1.3.25 → 1.3.27

package/dist/types/ai.d.ts

@@ -0,0 +1,379 @@
+/**
+ * AI domain types
+ */
+/** Content part for multimodal messages */
+export interface ContentPart {
+    type: 'text' | 'image_url';
+    text?: string;
+    image_url?: {
+        url: string;
+        detail?: 'auto' | 'low' | 'high';
+    };
+}
+/** Function call representation */
+export interface FunctionCall {
+    name: string;
+    arguments: string;
+}
+/** Tool call representation */
+export interface ToolCall {
+    id: string;
+    type: 'function';
+    function: {
+        name: string;
+        arguments: string;
+    };
+}
+/** Chat message with role and content */
+export interface ChatMessage {
+    role: 'system' | 'user' | 'assistant' | 'function' | 'tool';
+    content: string | ContentPart[];
+    name?: string;
+    function_call?: FunctionCall;
+    tool_calls?: ToolCall[];
+    tool_call_id?: string;
+}
+/** Tool/Function definition */
+export interface ToolDefinition {
+    type: 'function';
+    function: {
+        name: string;
+        description: string;
+        parameters: {
+            type: 'object';
+            properties: Record<string, {
+                type: string;
+                description?: string;
+                enum?: string[];
+            }>;
+            required?: string[];
+        };
+    };
+}
+/** Chat completion request */
+export interface ChatCompletionRequest {
+    messages: ChatMessage[];
+    model?: string;
+    stream?: boolean;
+    tools?: ToolDefinition[];
+    tool_choice?: 'none' | 'auto' | 'required' | {
+        type: 'function';
+        function: {
+            name: string;
+        };
+    };
+    temperature?: number;
+    max_tokens?: number;
+    top_p?: number;
+    frequency_penalty?: number;
+    presence_penalty?: number;
+    response_format?: {
+        type: 'text' | 'json_object';
+    };
+    user?: string;
+}
+/** Chat completion choice */
+export interface ChatCompletionChoice {
+    index: number;
+    message: ChatMessage;
+    finish_reason: 'stop' | 'length' | 'function_call' | 'tool_calls' | 'content_filter' | null;
+}
+/** Chat completion response */
+export interface ChatCompletionResponse {
+    id: string;
+    object: 'chat.completion';
+    created: number;
+    model: string;
+    choices: ChatCompletionChoice[];
+    usage: {
+        prompt_tokens: number;
+        completion_tokens: number;
+        total_tokens: number;
+    };
+}
+/** Streaming chunk */
+export interface ChatCompletionChunk {
+    id: string;
+    object: 'chat.completion.chunk';
+    created: number;
+    model: string;
+    choices: Array<{
+        index: number;
+        delta: Partial<ChatMessage>;
+        finish_reason: string | null;
+    }>;
+}
+/** AI Model information */
+export interface AIModel {
+    id: string;
+    provider: 'gemini' | 'openai';
+    modelId: string;
+    name: string;
+    description: string;
+    capabilities: Array<'text' | 'vision' | 'audio' | 'code'>;
+    contextWindow: number;
+    pricing: {
+        input: number;
+        output: number;
+        cached?: number;
+    };
+    features: string[];
+    recommended?: string;
+}
+/** Document chunk with embedding */
+export interface DocumentChunk {
+    text: string;
+    embedding: number[];
+    metadata: {
+        chunkIndex: number;
+        documentId: string;
+        [key: string]: any;
+    };
+}
+/** Index document request */
+export interface IndexDocumentRequest {
+    productId: string;
+    text?: string;
+    documentUrl?: string;
+    metadata?: Record<string, any>;
+    chunkSize?: number;
+    overlap?: number;
+    provider?: 'openai' | 'gemini';
+}
+/** Index document response */
+export interface IndexDocumentResponse {
+    success: boolean;
+    productId: string;
+    documentId: string;
+    chunks: number;
+    metadata: {
+        textLength: number;
+        chunkSize: number;
+        overlap: number;
+        embeddingDimensions: number;
+    };
+    sample?: {
+        text: string;
+        chunkIndex: number;
+    };
+}
+/** Configure assistant request */
+export interface ConfigureAssistantRequest {
+    productId: string;
+    systemPrompt?: string;
+    model?: string;
+    maxTokensPerResponse?: number;
+    temperature?: number;
+    rateLimitPerUser?: number;
+    allowedTopics?: string[];
+    customInstructions?: {
+        tone?: string;
+        additionalRules?: string;
+        [key: string]: any;
+    };
+}
+/** Configure assistant response */
+export interface ConfigureAssistantResponse {
+    success: boolean;
+    configuration: {
+        productId: string;
+        systemPrompt: string;
+        model: string;
+        maxTokensPerResponse: number;
+        temperature: number;
+        rateLimitPerUser: number;
+        allowedTopics: string[];
+        customInstructions?: Record<string, any>;
+        updatedAt: string;
+    };
+}
+/** Public chat request */
+export interface PublicChatRequest {
+    productId: string;
+    userId: string;
+    message: string;
+    sessionId?: string;
+    stream?: boolean;
+}
+/** Public chat response */
+export interface PublicChatResponse {
+    message: string;
+    sessionId: string;
+    usage: {
+        prompt_tokens: number;
+        completion_tokens: number;
+        total_tokens: number;
+    };
+    context?: {
+        chunksUsed: number;
+        topSimilarity: number;
+    };
+}
+/** Session information */
+export interface Session {
+    sessionId: string;
+    productId: string;
+    userId: string;
+    messageCount: number;
+    createdAt: string;
+    lastActivityAt: string;
+    messages: ChatMessage[];
+}
+/** Rate limit status */
+export interface RateLimitStatus {
+    used: number;
+    remaining: number;
+    resetAt: string;
+}
+/** Session statistics */
+export interface SessionStatistics {
+    totalSessions: number;
+    activeSessions: number;
+    totalMessages: number;
+    rateLimitedUsers: number;
+}
+/** Voice session request */
+export interface VoiceSessionRequest {
+    productId: string;
+    userId: string;
+    collectionId: string;
+    settings?: {
+        voice?: string;
+        language?: string;
+        model?: string;
+    };
+}
+/** Voice session response */
+export interface VoiceSessionResponse {
+    token: string;
+    systemInstruction: string;
+    expiresAt: string;
+    productName: string;
+}
+/** Ephemeral token request */
+export interface EphemeralTokenRequest {
+    settings?: {
+        ttl?: number;
+        voice?: string;
+        language?: string;
+        model?: string;
+    };
+}
+/** Ephemeral token response */
+export interface EphemeralTokenResponse {
+    token: string;
+    expiresAt: string;
+}
+/** Transcription response */
+export interface TranscriptionResponse {
+    text: string;
+}
+/** TTS request */
+export interface TTSRequest {
+    text: string;
+    voice?: 'alloy' | 'echo' | 'fable' | 'onyx' | 'nova' | 'shimmer';
+    speed?: number;
+    format?: 'mp3' | 'opus' | 'aac' | 'flac';
+}
+/** Podcast generation request */
+export interface GeneratePodcastRequest {
+    productId: string;
+    documentText?: string;
+    duration?: number;
+    style?: 'casual' | 'professional' | 'educational' | 'entertaining';
+    voices?: {
+        host1?: string;
+        host2?: string;
+    };
+    includeAudio?: boolean;
+    language?: string;
+    customInstructions?: string;
+}
+/** Podcast script */
+export interface PodcastScript {
+    title: string;
+    description: string;
+    segments: Array<{
+        speaker: 'host1' | 'host2';
+        text: string;
+        timestamp?: number;
+        duration?: number;
+    }>;
+}
+/** Podcast generation response */
+export interface GeneratePodcastResponse {
+    success: boolean;
+    podcastId: string;
+    script: PodcastScript;
+    audio?: {
+        host1Url?: string;
+        host2Url?: string;
+        mixedUrl?: string;
+    };
+    metadata: {
+        duration: number;
+        wordCount: number;
+        generatedAt: string;
+    };
+}
+/** Podcast status */
+export interface PodcastStatus {
+    podcastId: string;
+    status: 'generating_script' | 'generating_audio' | 'mixing' | 'completed' | 'failed';
+    progress: number;
+    estimatedTimeRemaining?: number;
+    error?: string;
+    result?: GeneratePodcastResponse;
+}
+/** Request shape for AI generateContent calls */
+export interface AIGenerateContentRequest {
+    /** The prompt or message contents sent to the AI */
+    contents: string | any;
+    /** Desired MIME type of the response payload (e.g. 'application/json', 'text/plain') */
+    responseMimeType?: string;
+    /** Optional system instruction or system prompt to steer the model */
+    systemInstruction?: string;
+    /** AI provider identifier (e.g. 'openai', 'google', 'anthropic') */
+    provider?: string;
+    /** The model name to use (e.g. 'gpt-4o', 'gemini-1.5-pro') */
+    model?: string;
+    /** Allow passing additional provider/model-specific options */
+    [key: string]: any;
+}
+/** Request shape for AI generateImage calls (admin) */
+export interface AIGenerateImageRequest {
+    /** Text prompt describing the desired image */
+    prompt: string;
+    /** AI provider identifier (e.g. 'openai', 'google', 'stability') */
+    provider?: string;
+    /** Optional model name to use for image generation */
+    model?: string;
+    /** Requested image size, e.g. '1024x1024' */
+    size?: string;
+    /** Additional provider/model-specific options */
+    [key: string]: any;
+}
+/** Request shape for AI searchPhotos calls (admin -> Unsplash proxy) */
+export interface AISearchPhotosRequest {
+    /** Search query keyword(s) */
+    query: string;
+    /** Number of results to return per page (e.g. 1) */
+    per_page?: number;
+    /** Desired orientation of photos */
+    orientation?: 'landscape' | 'portrait' | 'squarish';
+    /** Additional provider-specific options */
+    [key: string]: any;
+}
+/** Single photo item returned by searchPhotos */
+export interface AISearchPhotosPhoto {
+    /** Direct image URL */
+    url: string;
+    /** Alt text/description for accessibility */
+    alt?: string;
+    /** Photographer display name */
+    photographer?: string;
+    /** Link to the photographer profile */
+    photographerUrl?: string;
+    /** Allow extra fields */
+    [key: string]: any;
+}

package/dist/types/ai.js

@@ -0,0 +1,5 @@
+// src/types/ai.ts
+/**
+ * AI domain types
+ */
+export {};

package/dist/types/collection.d.ts

@@ -62,6 +62,7 @@ export interface Collection {
     shortId: string;
     /** if dark mode is enabled for this collection */
     dark?: boolean;
+    portalUrl?: string;
 }
 export type CollectionResponse = Collection;
 export type CollectionCreateRequest = Omit<Collection, 'id' | 'shortId'>;

package/dist/types/index.d.ts

@@ -26,3 +26,4 @@ export * from "./tags";
 export * from "./order";
 export * from "./crate";
 export * from "./iframeResponder";
+export * from "./ai";

package/dist/types/index.js

@@ -28,3 +28,4 @@ export * from "./tags";
 export * from "./order";
 export * from "./crate";
 export * from "./iframeResponder";
+export * from "./ai";

package/dist/utils/conditions.d.ts

@@ -0,0 +1,287 @@
+/**
+ * Geographic region definitions for country-based conditions
+ */
+export declare const REGION_COUNTRIES: {
+    readonly eu: readonly ["AT", "BE", "BG", "HR", "CY", "CZ", "DK", "EE", "FI", "FR", "DE", "GR", "HU", "IE", "IT", "LV", "LT", "LU", "MT", "NL", "PL", "PT", "RO", "SK", "SI", "ES", "SE"];
+    readonly eea: readonly ["AT", "BE", "BG", "HR", "CY", "CZ", "DK", "EE", "FI", "FR", "DE", "GR", "HU", "IE", "IT", "LV", "LT", "LU", "MT", "NL", "PL", "PT", "RO", "SK", "SI", "ES", "SE", "IS", "LI", "NO"];
+    readonly uk: readonly ["GB"];
+    readonly northamerica: readonly ["US", "CA", "MX"];
+    readonly asiapacific: readonly ["AU", "NZ", "JP", "KR", "SG", "HK", "TW", "TH", "MY", "PH", "ID", "VN", "IN"];
+};
+export type RegionKey = keyof typeof REGION_COUNTRIES;
+/**
+ * Base condition structure
+ */
+export interface BaseCondition {
+    type: string;
+    contains?: boolean;
+    passes?: boolean;
+}
+/**
+ * Country-based condition
+ */
+export interface CountryCondition extends BaseCondition {
+    type: 'country';
+    countries?: string[];
+    useRegions?: boolean;
+    regions?: RegionKey[];
+    contains: boolean;
+}
+/**
+ * Version-based condition
+ */
+export interface VersionCondition extends BaseCondition {
+    type: 'version';
+    versions: string[];
+    contains: boolean;
+}
+/**
+ * Device/platform condition
+ */
+export interface DeviceCondition extends BaseCondition {
+    type: 'device';
+    displays: Array<'android' | 'ios' | 'win' | 'mac' | 'desktop' | 'mobile'>;
+    contains: boolean;
+}
+/**
+ * Nested condition reference
+ */
+export interface NestedCondition extends BaseCondition {
+    type: 'condition';
+    conditionId: string;
+    passes: boolean;
+}
+/**
+ * User type condition
+ */
+export interface UserCondition extends BaseCondition {
+    type: 'user';
+    userType: 'valid' | 'invalid' | 'owner' | 'admin' | 'group';
+    groupId?: string;
+}
+/**
+ * Product-based condition
+ */
+export interface ProductCondition extends BaseCondition {
+    type: 'product';
+    productIds: string[];
+    contains: boolean;
+}
+/**
+ * Tag-based condition
+ */
+export interface TagCondition extends BaseCondition {
+    type: 'tag';
+    tags: string[];
+    contains: boolean;
+}
+/**
+ * Date-based condition
+ */
+export interface DateCondition extends BaseCondition {
+    type: 'date';
+    dateTest: 'before' | 'after' | 'between';
+    beforeDate?: string;
+    afterDate?: string;
+    rangeDate?: [string, string];
+}
+/**
+ * Geofence condition
+ */
+export interface GeofenceCondition extends BaseCondition {
+    type: 'geofence';
+    top: number;
+    bottom: number;
+    left: number;
+    right: number;
+    contains: boolean;
+}
+/**
+ * Value comparison condition
+ */
+export interface ValueCondition extends BaseCondition {
+    type: 'value';
+    field: string;
+    fieldType: 'string' | 'boolean' | 'integer' | 'number';
+    validationType: 'equal' | 'not' | 'greater' | 'less';
+    value: string | number | boolean;
+}
+/**
+ * Item status condition
+ */
+export interface ItemStatusCondition extends BaseCondition {
+    type: 'itemStatus';
+    statusType: 'isClaimable' | 'notClaimable' | 'noProof' | 'hasProof' | 'isVirtual' | 'notVirtual';
+}
+/**
+ * Union of all condition types
+ */
+export type Condition = CountryCondition | VersionCondition | DeviceCondition | NestedCondition | UserCondition | ProductCondition | TagCondition | DateCondition | GeofenceCondition | ValueCondition | ItemStatusCondition;
+/**
+ * Condition set that combines multiple conditions
+ */
+export interface ConditionSet {
+    id?: string;
+    type?: 'and' | 'or';
+    conditions?: Condition[];
+}
+/**
+ * User location information
+ */
+export interface UserLocation {
+    country?: string;
+    latitude?: number;
+    longitude?: number;
+}
+/**
+ * Platform detection information
+ */
+export interface PlatformInfo {
+    android?: boolean;
+    ios?: boolean;
+    win?: boolean;
+    mac?: boolean;
+}
+/**
+ * Statistics/tracking information
+ */
+export interface StatsInfo {
+    version?: string | null;
+    platform?: PlatformInfo;
+    mobile?: boolean;
+}
+/**
+ * User information for condition validation
+ */
+export interface UserInfo {
+    valid: boolean;
+    uid?: string;
+    location?: UserLocation;
+    groups?: string[];
+}
+/**
+ * Product information for condition validation
+ */
+export interface ProductInfo {
+    id: string;
+    tags?: Record<string, any>;
+}
+/**
+ * Proof information for condition validation
+ */
+export interface ProofInfo {
+    id?: string;
+    userId?: string;
+    claimable?: boolean;
+    virtual?: boolean;
+}
+/**
+ * Collection information for condition validation
+ */
+export interface CollectionInfo {
+    id: string;
+    roles?: Record<string, any>;
+}
+/**
+ * Parameters for condition validation
+ */
+export interface ConditionParams {
+    /** The condition set to validate (if not using conditionId) */
+    condition?: ConditionSet;
+    /** ID of a condition to load and validate */
+    conditionId?: string;
+    /** Stack to prevent infinite recursion in nested conditions */
+    conditionStack?: string[];
+    /** User information */
+    user?: UserInfo;
+    /** Product information */
+    product?: ProductInfo;
+    /** Proof information */
+    proof?: ProofInfo;
+    /** Collection information */
+    collection?: CollectionInfo;
+    /** Statistics/tracking information */
+    stats?: StatsInfo;
+    /** Function to fetch conditions by ID (optional) */
+    fetchCondition?: (collectionId: string, conditionId: string) => Promise<ConditionSet | null>;
+    /** Function to get user's current location (optional) */
+    getLocation?: () => Promise<{
+        latitude: number;
+        longitude: number;
+    }>;
+    /** Any additional custom fields for value-based conditions */
+    [key: string]: any;
+}
+/**
+ * Validates if a condition set passes based on the provided parameters.
+ *
+ * Conditions are commonly used for controlling page rendering, content visibility,
+ * and feature access based on various criteria like geography, device type, user status, etc.
+ *
+ * Supports multiple condition types:
+ * - **country** - Geographic restrictions (countries or regions like EU, EEA)
+ * - **version** - Version-based display (e.g., A/B testing)
+ * - **device** - Platform/device targeting (iOS, Android, desktop, mobile)
+ * - **user** - User authentication status (logged in, owner, admin)
+ * - **product** - Product-specific conditions
+ * - **tag** - Product tag-based conditions
+ * - **date** - Time-based conditions (before, after, between dates)
+ * - **geofence** - Location-based restrictions
+ * - **value** - Custom field comparisons
+ * - **itemStatus** - Proof/item status checks (claimable, virtual, etc.)
+ * - **condition** - Nested condition references
+ *
+ * Conditions can be combined with AND or OR logic.
+ *
+ * @param params - Validation parameters including condition and context
+ * @returns Promise that resolves to true if condition passes, false otherwise
+ *
+ * @example
+ * ```typescript
+ * import { validateCondition } from '@proveanything/smartlinks'
+ *
+ * // Simple country check
+ * const canShow = await validateCondition({
+ *   condition: {
+ *     type: 'and',
+ *     conditions: [{
+ *       type: 'country',
+ *       useRegions: true,
+ *       regions: ['eu'],
+ *       contains: true
+ *     }]
+ *   },
+ *   user: { valid: true, location: { country: 'DE' } }
+ * })
+ *
+ * // Multiple conditions with AND logic
+ * const result = await validateCondition({
+ *   condition: {
+ *     type: 'and',
+ *     conditions: [
+ *       { type: 'user', userType: 'valid' },
+ *       { type: 'device', displays: ['mobile'], contains: true }
+ *     ]
+ *   },
+ *   user: { valid: true },
+ *   stats: { mobile: true }
+ * })
+ *
+ * // Date-based condition
+ * const isActive = await validateCondition({
+ *   condition: {
+ *     type: 'and',
+ *     conditions: [{
+ *       type: 'date',
+ *       dateTest: 'between',
+ *       rangeDate: ['2026-01-01', '2026-12-31']
+ *     }]
+ *   }
+ * })
+ * ```
+ */
+export declare function validateCondition(params: ConditionParams): Promise<boolean>;
+/**
+ * Clear the condition cache
+ */
+export declare function clearConditionCache(): void;