@payware/mcp-server 1.0.0

package/src/utils/code-examples/shared/soundbites.js

@@ -0,0 +1,808 @@
+/**
+ * Soundbite operations examples (shared across all partner types)
+ */
+
+import { ExampleGenerator, CommonTemplates } from '../common/helpers.js';
+
+/**
+ * Soundbite operations for audio content and payment integration
+ */
+export const SoundbiteOperations = {
+  register_audio: {
+    description: 'Register audio content for soundbite transactions',
+    endpoint: '/products/{id}/audios/upload',
+    method: 'POST',
+    contentType: 'multipart/form-data',
+    sampleBody: {
+      file: '@/path/to/audio.mp3'
+    }
+  },
+
+  get_audio: {
+    description: 'Get audio content details',
+    endpoint: '/products/{id}/audios/{audioId}',
+    method: 'GET',
+    sampleBody: null
+  },
+
+  update_audio: {
+    description: 'Update audio content metadata',
+    endpoint: '/products/{id}/audios/{audioId}',
+    method: 'PATCH',
+    sampleBody: {
+      title: 'Updated Audio Title',
+      productId: 'pr_new_product_123'
+    }
+  },
+
+  delete_audio: {
+    description: 'Delete audio content',
+    endpoint: '/products/{id}/audios/{audioId}',
+    method: 'DELETE',
+    sampleBody: null
+  },
+
+  list_audios: {
+    description: 'List audio content for product',
+    endpoint: '/products/{id}/audios',
+    method: 'GET',
+    sampleBody: null,
+    queryParams: {
+      format: 'MP3',
+      quality: 'HIGH',
+      limit: 20,
+      offset: 0
+    }
+  },
+
+  create_soundbite_transaction: {
+    description: 'Create transaction for soundbite purchase',
+    endpoint: '/transactions/soundbite',
+    method: 'POST',
+    sampleBody: {
+      trData: {
+        amount: '2.99',
+        currency: 'EUR',
+        reasonL1: 'Soundbite Purchase',
+        reasonL2: 'Premium audio content'
+      },
+      soundbiteData: {
+        productId: 'pr_audio_123',
+        audioId: 'aud_content_456',
+        accessType: 'STREAM_ONLY',
+        duration: 180,
+        quality: 'HIGH'
+      },
+      trOptions: {
+        type: 'SOUNDBITE',
+        timeToLive: 300,
+        autoComplete: true,
+        deliveryMethod: 'INSTANT_STREAM'
+      }
+    }
+  },
+
+  stream_audio: {
+    description: 'Stream audio content after purchase',
+    endpoint: '/soundbites/{id}/stream',
+    method: 'GET',
+    sampleBody: null,
+    queryParams: {
+      quality: 'HIGH',
+      format: 'MP3',
+      startTime: 0,
+      duration: 180
+    },
+    responseType: 'audio'
+  },
+
+  download_audio: {
+    description: 'Download purchased audio content',
+    endpoint: '/soundbites/{id}/download',
+    method: 'GET',
+    sampleBody: null,
+    queryParams: {
+      quality: 'HIGHEST',
+      format: 'FLAC'
+    },
+    responseType: 'file'
+  },
+
+  get_soundbite_analytics: {
+    description: 'Get analytics for soundbite transactions',
+    endpoint: '/soundbites/analytics',
+    method: 'GET',
+    sampleBody: null,
+    queryParams: {
+      period: '30d',
+      metrics: 'purchases,streams,revenue',
+      productId: 'pr_audio_123',
+      groupBy: 'day'
+    }
+  },
+
+  create_audio_playlist: {
+    description: 'Create playlist from multiple audio contents',
+    endpoint: '/soundbites/playlists',
+    method: 'POST',
+    sampleBody: {
+      playlistData: {
+        name: 'Premium Collection',
+        description: 'Curated premium audio content',
+        isPublic: false,
+        category: 'PREMIUM'
+      },
+      audioItems: [
+        {
+          audioId: 'aud_content_001',
+          position: 1,
+          startTime: 0,
+          endTime: 180
+        },
+        {
+          audioId: 'aud_content_002',
+          position: 2,
+          startTime: 30,
+          endTime: 210
+        }
+      ],
+      playlistOptions: {
+        shuffle: false,
+        repeat: false,
+        autoPlay: true,
+        crossfade: 2
+      }
+    }
+  },
+
+  get_audio_preview: {
+    description: 'Get preview of audio content before purchase',
+    endpoint: '/products/{id}/audios/{audioId}/preview',
+    method: 'GET',
+    sampleBody: null,
+    queryParams: {
+      duration: 30,
+      startTime: 60,
+      quality: 'MEDIUM'
+    },
+    responseType: 'audio'
+  }
+};
+
+/**
+ * Python Soundbites Generator
+ */
+export class PythonSoundbitesGenerator extends ExampleGenerator {
+  constructor() {
+    super('python');
+  }
+
+  getOperationTemplate(operation, partnerType, params = {}) {
+    const opConfig = SoundbiteOperations[operation];
+    if (!opConfig) {
+      throw new Error(`Unknown operation: ${operation}`);
+    }
+
+    const {
+      productId = 'pr_audio_123',
+      audioId = 'aud_content_456',
+      soundbiteId = 'sb_transaction_789',
+      playlistId = 'pl_collection_012',
+      ...otherParams
+    } = params;
+
+    let endpoint = opConfig.endpoint;
+    endpoint = endpoint.replace('{id}', productId);
+    endpoint = endpoint.replace('{audioId}', audioId);
+    endpoint = endpoint.replace('{soundbiteId}', soundbiteId);
+    endpoint = endpoint.replace('{playlistId}', playlistId);
+
+    const functionName = `${operation}_example`;
+
+    return `def ${functionName}(${this.getFunctionParams(operation, productId, audioId, soundbiteId)}, use_sandbox=True):
+    """${opConfig.description}"""
+
+    try:
+        # Get API configuration
+        base_url = get_api_base_url(use_sandbox)
+        endpoint = '${endpoint}'
+        url = f"{base_url}{endpoint}"
+
+        ${this.getQueryParamsSection(operation, opConfig)}
+        ${this.getRequestBodySection(operation, opConfig)}
+
+        # Create JWT token
+        token, body_string = create_jwt_token(request_body, use_sandbox)
+        headers = get_api_headers(token)
+
+        ${this.getSpecialHandling(operation, opConfig)}
+
+        ${this.getRequestSection(opConfig.method, opConfig.responseType)}
+
+        ${this.getResponseHandling(operation, opConfig)}
+
+    except requests.exceptions.RequestException as e:
+        print(f"Request error: {str(e)}")
+        return None
+    except Exception as e:
+        print(f"Unexpected error: {str(e)}")
+        return None
+
+def validate_audio_format(audio_data):
+    """Validate audio format and specifications"""
+
+    supported_formats = ['MP3', 'FLAC', 'WAV', 'AAC']
+    format_type = audio_data.get('format', '').upper()
+
+    if format_type not in supported_formats:
+        print(f"Warning: Unsupported audio format: {format_type}")
+        return False
+
+    duration = audio_data.get('duration', 0)
+    if duration <= 0 or duration > 3600:  # Max 1 hour
+        print(f"Warning: Invalid audio duration: {duration} seconds")
+        return False
+
+    bitrate = audio_data.get('bitrate', 0)
+    if bitrate < 64 or bitrate > 1411:  # 64kbps to 1411kbps (FLAC)
+        print(f"Warning: Invalid bitrate: {bitrate} kbps")
+        return False
+
+    return True
+
+def save_audio_file(audio_data, filename=None):
+    """Save streamed audio data to file"""
+
+    if not filename:
+        timestamp = int(time.time())
+        filename = f"soundbite_{timestamp}.mp3"
+
+    try:
+        with open(filename, 'wb') as f:
+            for chunk in audio_data.iter_content(chunk_size=8192):
+                f.write(chunk)
+
+        print(f"Audio saved as: {filename}")
+        return filename
+    except Exception as e:
+        print(f"Error saving audio: {str(e)}")
+        return None
+
+def calculate_audio_price(duration, quality, format_type):
+    """Calculate price for audio content based on specifications"""
+
+    base_price = 0.99  # Base price in EUR
+    duration_multiplier = max(1, duration / 60)  # Per minute
+    quality_multiplier = {'LOW': 0.8, 'MEDIUM': 1.0, 'HIGH': 1.3, 'HIGHEST': 1.6}
+    format_multiplier = {'MP3': 1.0, 'FLAC': 1.5, 'WAV': 1.3, 'AAC': 1.1}
+
+    total_price = (base_price *
+                  duration_multiplier *
+                  quality_multiplier.get(quality, 1.0) *
+                  format_multiplier.get(format_type, 1.0))
+
+    return round(total_price, 2)
+
+# Example usage
+if __name__ == "__main__":
+    print("Soundbites Example")
+
+    # ${opConfig.description}
+    result = ${functionName}()
+
+    if result:
+        print("Soundbite operation completed successfully")
+        ${this.getUsageExample(operation)}
+    else:
+        print("Soundbite operation failed")`;
+  }
+
+  getFunctionParams(operation, productId, audioId, soundbiteId) {
+    const params = [];
+
+    if (operation.includes('audio') || operation.includes('register') || operation.includes('list')) {
+      params.push(`product_id='${productId}'`);
+      if (!operation.includes('list') && !operation.includes('register')) {
+        params.push(`audio_id='${audioId}'`);
+      }
+    } else if (operation.includes('soundbite') || operation.includes('stream') || operation.includes('download')) {
+      params.push(`soundbite_id='${soundbiteId}'`);
+    }
+
+    return params.join(', ');
+  }
+
+  getQueryParamsSection(operation, opConfig) {
+    if (!opConfig.queryParams) {
+      return '';
+    }
+
+    const paramsStr = Object.entries(opConfig.queryParams)
+      .map(([key, value]) => `        '${key}': ${typeof value === 'string' ? `'${value}'` : value}`)
+      .join(',\n');
+
+    return `# Add query parameters
+    params = {
+${paramsStr}
+    }
+    if params:
+        url += '?' + '&'.join([f"{k}={v}" for k, v in params.items()])`;
+  }
+
+  getRequestBodySection(operation, opConfig) {
+    if (!opConfig.sampleBody) {
+      return '# No request body needed for this operation\n        request_body = None';
+    }
+
+    const bodyStr = JSON.stringify(opConfig.sampleBody, null, 8).replace(/^/gm, '        ');
+
+    let validation = '';
+    if (operation === 'register_audio') {
+      validation = `
+        # Validate audio specifications
+        if 'audioData' in request_body:
+            if not validate_audio_format(request_body['audioData']):
+                print("Warning: Audio validation failed")`;
+    }
+
+    return `# Prepare request body
+        request_body = ${bodyStr}${validation}`;
+  }
+
+  getSpecialHandling(operation, opConfig) {
+    if (opConfig.responseType === 'audio' || opConfig.responseType === 'file') {
+      return `# Set headers for audio/file response
+        headers['Accept'] = 'audio/*' if '${opConfig.responseType}' == 'audio' else 'application/octet-stream'`;
+    }
+    return '';
+  }
+
+  getRequestSection(method, responseType) {
+    if (method === 'GET') {
+      if (responseType === 'audio' || responseType === 'file') {
+        return 'response = requests.get(url, headers=headers, stream=True)';
+      }
+      return 'response = requests.get(url, headers=headers)';
+    } else if (method === 'DELETE') {
+      return 'response = requests.delete(url, headers=headers, data=body_string if request_body else None)';
+    } else {
+      return `response = requests.${method.toLowerCase()}(
+            url,
+            headers=headers,
+            data=body_string if request_body else None
+        )`;
+    }
+  }
+
+  getResponseHandling(operation, opConfig) {
+    if (opConfig.responseType === 'audio' || opConfig.responseType === 'file') {
+      return `if response.status_code == 200:
+            # Handle audio/file download
+            content_type = response.headers.get('content-type', '')
+            file_extension = 'mp3' if 'audio' in content_type else 'dat'
+            filename = f"{operation}_{soundbite_id if 'soundbite' in locals() else audio_id}.{file_extension}"
+
+            saved_file = save_audio_file(response, filename)
+            if saved_file:
+                print(f"${opConfig.description} successful - file saved: {saved_file}")
+                return {'filename': saved_file, 'content_type': content_type}
+            else:
+                print("Failed to save audio file")
+                return None
+        else:
+            error_msg = f"Request failed with status {response.status_code}: {response.text}"
+            print(error_msg)
+            return None`;
+    } else {
+      return `if response.status_code == 200:
+            result = response.json()
+            print(f"${opConfig.description} successful:")
+            print(json.dumps(result, indent=2))
+            return result
+        else:
+            error_msg = f"Request failed with status {response.status_code}: {response.text}"
+            print(error_msg)
+            return None`;
+    }
+  }
+
+  getUsageExample(operation) {
+    const examples = {
+      register_audio: `# Store audio ID for transactions
+        if 'audioId' in result:
+            audio_id = result['audioId']
+            print(f"Audio registered: {audio_id}")
+            print("Use create_soundbite_transaction_example() to enable purchases")`,
+
+      create_soundbite_transaction: `# Monitor transaction and enable access
+        if 'transactionId' in result:
+            transaction_id = result['transactionId']
+            soundbite_id = result.get('soundbiteId')
+            print(f"Soundbite transaction: {transaction_id}")
+            if soundbite_id:
+                print(f"Access with: stream_audio_example('{soundbite_id}')")`,
+
+      stream_audio: `# Audio streaming started
+        if 'filename' in result:
+            print(f"Audio streamed and saved: {result['filename']}")
+            print("Playback can begin immediately")`,
+
+      get_soundbite_analytics: `# Display analytics insights
+        analytics = result.get('analytics', {})
+        period = result.get('period')
+
+        print(f"Soundbite Analytics for {period}:")
+        for metric, data in analytics.items():
+            if isinstance(data, dict):
+                print(f"- {metric}:")
+                for key, value in data.items():
+                    print(f"  - {key}: {value}")
+            else:
+                print(f"- {metric}: {data}")
+
+        # Calculate revenue per stream
+        if 'purchases' in analytics and 'revenue' in analytics:
+            purchases = analytics['purchases']
+            revenue = analytics['revenue']
+            if purchases > 0:
+                avg_revenue = revenue / purchases
+                print(f"\\nAverage revenue per purchase: €{avg_revenue:.2f}")`
+    };
+
+    return examples[operation] || '# Process soundbite result as needed';
+  }
+}
+
+/**
+ * Node.js Soundbites Generator
+ */
+export class NodeJSSoundbitesGenerator extends ExampleGenerator {
+  constructor() {
+    super('nodejs');
+  }
+
+  getOperationTemplate(operation, partnerType, params = {}) {
+    const opConfig = SoundbiteOperations[operation];
+    if (!opConfig) {
+      throw new Error(`Unknown operation: ${operation}`);
+    }
+
+    const {
+      productId = 'pr_audio_123',
+      audioId = 'aud_content_456',
+      soundbiteId = 'sb_transaction_789',
+      playlistId = 'pl_collection_012',
+      ...otherParams
+    } = params;
+
+    let endpoint = opConfig.endpoint;
+    endpoint = endpoint.replace('{id}', productId);
+    endpoint = endpoint.replace('{audioId}', audioId);
+    endpoint = endpoint.replace('{soundbiteId}', soundbiteId);
+    endpoint = endpoint.replace('{playlistId}', playlistId);
+
+    const functionName = `${operation}Example`;
+
+    return `async function ${functionName}(${this.getFunctionParams(operation, productId, audioId, soundbiteId)}, useSandbox = true) {
+  /**
+   * ${opConfig.description}
+   */
+
+  try {
+    // Get API configuration
+    const baseUrl = getAPIBaseURL(useSandbox);
+    const endpoint = '${endpoint}';
+    let url = \`\${baseUrl}\${endpoint}\`;
+
+    ${this.getQueryParamsSection(operation, opConfig)}
+    ${this.getRequestBodySection(operation, opConfig)}
+
+    // Create JWT token
+    const { token, bodyString } = createJWTToken(requestBody, useSandbox);
+    const headers = getAPIHeaders(token);
+
+    ${this.getSpecialHandling(operation, opConfig)}
+
+    ${this.getRequestSection(opConfig.method, opConfig.responseType)}
+
+    ${this.getResponseHandling(operation, opConfig)}
+
+  } catch (error) {
+    if (error.response) {
+      console.error(\`API Error: \${error.response.status} - \${error.response.data}\`);
+    } else {
+      console.error('Request Error:', error.message);
+    }
+    return null;
+  }
+}
+
+function validateAudioFormat(audioData) {
+  /**
+   * Validate audio format and specifications
+   */
+
+  const supportedFormats = ['MP3', 'FLAC', 'WAV', 'AAC'];
+  const formatType = (audioData.format || '').toUpperCase();
+
+  if (!supportedFormats.includes(formatType)) {
+    console.warn(\`Warning: Unsupported audio format: \${formatType}\`);
+    return false;
+  }
+
+  const duration = audioData.duration || 0;
+  if (duration <= 0 || duration > 3600) { // Max 1 hour
+    console.warn(\`Warning: Invalid audio duration: \${duration} seconds\`);
+    return false;
+  }
+
+  const bitrate = audioData.bitrate || 0;
+  if (bitrate < 64 || bitrate > 1411) { // 64kbps to 1411kbps (FLAC)
+    console.warn(\`Warning: Invalid bitrate: \${bitrate} kbps\`);
+    return false;
+  }
+
+  return true;
+}
+
+function saveAudioFile(audioData, filename) {
+  /**
+   * Save streamed audio data to file
+   */
+  const fs = require('fs');
+
+  if (!filename) {
+    const timestamp = Date.now();
+    filename = \`soundbite_\${timestamp}.mp3\`;
+  }
+
+  return new Promise((resolve, reject) => {
+    const writer = fs.createWriteStream(filename);
+    audioData.pipe(writer);
+
+    writer.on('finish', () => {
+      console.log(\`Audio saved as: \${filename}\`);
+      resolve(filename);
+    });
+
+    writer.on('error', (error) => {
+      console.error(\`Error saving audio: \${error.message}\`);
+      reject(error);
+    });
+  });
+}
+
+function calculateAudioPrice(duration, quality, formatType) {
+  /**
+   * Calculate price for audio content based on specifications
+   */
+
+  const basePrice = 0.99; // Base price in EUR
+  const durationMultiplier = Math.max(1, duration / 60); // Per minute
+  const qualityMultiplier = { 'LOW': 0.8, 'MEDIUM': 1.0, 'HIGH': 1.3, 'HIGHEST': 1.6 };
+  const formatMultiplier = { 'MP3': 1.0, 'FLAC': 1.5, 'WAV': 1.3, 'AAC': 1.1 };
+
+  const totalPrice = basePrice *
+                    durationMultiplier *
+                    (qualityMultiplier[quality] || 1.0) *
+                    (formatMultiplier[formatType] || 1.0);
+
+  return Math.round(totalPrice * 100) / 100; // Round to 2 decimal places
+}
+
+// Example usage
+async function main() {
+  console.log('Soundbites Example');
+
+  try {
+    const result = await ${functionName}();
+
+    if (result) {
+      console.log('Soundbite operation completed successfully');
+      ${this.getUsageExample(operation)}
+    } else {
+      console.log('Soundbite operation failed');
+    }
+
+  } catch (error) {
+    console.error('Soundbite operation error:', error.message);
+  }
+}
+
+// Run example if this file is executed directly
+if (require.main === module) {
+  main().catch(console.error);
+}`;
+  }
+
+  getFunctionParams(operation, productId, audioId, soundbiteId) {
+    const params = [];
+
+    if (operation.includes('audio') || operation.includes('register') || operation.includes('list')) {
+      params.push(`productId = '${productId}'`);
+      if (!operation.includes('list') && !operation.includes('register')) {
+        params.push(`audioId = '${audioId}'`);
+      }
+    } else if (operation.includes('soundbite') || operation.includes('stream') || operation.includes('download')) {
+      params.push(`soundbiteId = '${soundbiteId}'`);
+    }
+
+    return params.join(', ');
+  }
+
+  getQueryParamsSection(operation, opConfig) {
+    if (!opConfig.queryParams) {
+      return '';
+    }
+
+    const paramsStr = JSON.stringify(opConfig.queryParams, null, 4).replace(/^/gm, '    ');
+    return `// Add query parameters
+    const queryParams = ${paramsStr};
+    const searchParams = new URLSearchParams(queryParams);
+    url += \`?\${searchParams.toString()}\`;`;
+  }
+
+  getRequestBodySection(operation, opConfig) {
+    if (!opConfig.sampleBody) {
+      return '// No request body needed for this operation\n    const requestBody = null;';
+    }
+
+    const bodyStr = JSON.stringify(opConfig.sampleBody, null, 4).replace(/^/gm, '    ');
+
+    let validation = '';
+    if (operation === 'register_audio') {
+      validation = `
+
+    // Validate audio specifications
+    if (requestBody.audioData) {
+      if (!validateAudioFormat(requestBody.audioData)) {
+        console.warn('Warning: Audio validation failed');
+      }
+    }`;
+    }
+
+    return `// Prepare request body
+    const requestBody = ${bodyStr};${validation}`;
+  }
+
+  getSpecialHandling(operation, opConfig) {
+    if (opConfig.responseType === 'audio' || opConfig.responseType === 'file') {
+      return `// Set headers for audio/file response
+    headers['Accept'] = '${opConfig.responseType}' === 'audio' ? 'audio/*' : 'application/octet-stream';`;
+    }
+    return '';
+  }
+
+  getRequestSection(method, responseType) {
+    if (method === 'GET') {
+      if (responseType === 'audio' || responseType === 'file') {
+        return `const response = await axios.get(url, {
+      headers,
+      responseType: 'stream'
+    });`;
+      }
+      return 'const response = await axios.get(url, { headers });';
+    } else if (method === 'DELETE') {
+      return `const response = await axios.delete(url, {
+      headers,
+      data: bodyString || undefined
+    });`;
+    } else {
+      return `const response = await axios.${method.toLowerCase()}(
+      url,
+      bodyString || undefined,
+      { headers }
+    );`;
+    }
+  }
+
+  getResponseHandling(operation, opConfig) {
+    if (opConfig.responseType === 'audio' || opConfig.responseType === 'file') {
+      return `if (response.status === 200) {
+      // Handle audio/file download
+      const contentType = response.headers['content-type'] || '';
+      const fileExtension = contentType.includes('audio') ? 'mp3' : 'dat';
+      const filename = \`\${operation}_\${soundbiteId || audioId}.\${fileExtension}\`;
+
+      try {
+        const savedFile = await saveAudioFile(response.data, filename);
+        console.log(\`${opConfig.description} successful - file saved: \${savedFile}\`);
+        return { filename: savedFile, contentType };
+      } catch (error) {
+        console.error('Failed to save audio file:', error.message);
+        return null;
+      }
+    } else {
+      console.error(\`Request failed with status \${response.status}: \${response.statusText}\`);
+      return null;
+    }`;
+    } else {
+      return `if (response.status === 200) {
+      const result = response.data;
+      console.log('${opConfig.description} successful:');
+      console.log(JSON.stringify(result, null, 2));
+      return result;
+    } else {
+      console.error(\`Request failed with status \${response.status}: \${response.statusText}\`);
+      return null;
+    }`;
+    }
+  }
+
+  getUsageExample(operation) {
+    const examples = {
+      register_audio: `// Store audio ID for transactions
+    if (result.audioId) {
+      const audioId = result.audioId;
+      console.log(\`Audio registered: \${audioId}\`);
+      console.log('Use createSoundbiteTransactionExample() to enable purchases');
+    }`,
+
+      create_soundbite_transaction: `// Monitor transaction and enable access
+    if (result.transactionId) {
+      const transactionId = result.transactionId;
+      const soundbiteId = result.soundbiteId;
+      console.log(\`Soundbite transaction: \${transactionId}\`);
+      if (soundbiteId) {
+        console.log(\`Access with: streamAudioExample('\${soundbiteId}')\`);
+      }
+    }`,
+
+      stream_audio: `// Audio streaming started
+    if (result.filename) {
+      console.log(\`Audio streamed and saved: \${result.filename}\`);
+      console.log('Playback can begin immediately');
+    }`,
+
+      get_soundbite_analytics: `// Display analytics insights
+    const analytics = result.analytics || {};
+    const period = result.period;
+
+    console.log(\`Soundbite Analytics for \${period}:\`);
+    Object.entries(analytics).forEach(([metric, data]) => {
+      if (typeof data === 'object' && data !== null) {
+        console.log(\`- \${metric}:\`);
+        Object.entries(data).forEach(([key, value]) => {
+          console.log(\`  - \${key}: \${value}\`);
+        });
+      } else {
+        console.log(\`- \${metric}: \${data}\`);
+      }
+    });
+
+    // Calculate revenue per stream
+    if (analytics.purchases && analytics.revenue) {
+      const purchases = analytics.purchases;
+      const revenue = analytics.revenue;
+      if (purchases > 0) {
+        const avgRevenue = revenue / purchases;
+        console.log(\`\\nAverage revenue per purchase: €\${avgRevenue.toFixed(2)}\`);
+      }
+    }`
+    };
+
+    return examples[operation] || '// Process soundbite result as needed';
+  }
+}
+
+/**
+ * Export all generators
+ */
+export const SoundbitesGenerators = {
+  python: PythonSoundbitesGenerator,
+  nodejs: NodeJSSoundbitesGenerator,
+  javascript: NodeJSSoundbitesGenerator
+};
+
+/**
+ * Generate soundbites example
+ */
+export function generateSoundbitesExample(operation, language = 'python', partnerType = 'merchant', options = {}) {
+  const GeneratorClass = SoundbitesGenerators[language];
+  if (!GeneratorClass) {
+    throw new Error(`Unsupported language: ${language}`);
+  }
+
+  const generator = new GeneratorClass();
+  return generator.generateExample(operation, partnerType, options);
+}