{
    "method": "GET",
    "url": "http://localhost:8000/api/nodes",
    "headers": {
        "Authorization": [
            "***REDACTED***"
        ],
        "Accept": "application/json",
        "Content-Type": "application/json"
    },
    "payload": {
        "query": {
            "project_id": 1
        }
    },
    "recorded_at": "2025-10-17T22:41:35+00:00"
}

// TellsTree SDK - Nodes API (JavaScript)
// List all nodes in a project

const API_BASE_URL = 'https://tellstree.com/api';
const API_TOKEN = 'your_jwt_token_here';

/**
 * Get all nodes for a specific project
 * @param {number} projectId - The ID of the project
 * @param {number} page - Page number (default: 1)
 * @param {number} perPage - Items per page (default: 20)
 * @returns {Promise<Object>} API response with nodes data
 */
async function listProjectNodes(projectId, page = 1, perPage = 20) {
    try {
        const params = new URLSearchParams({
            'query[project_id]': projectId,
            'query[page]': page,
            'query[per_page]': perPage
        });
        const url = `${API_BASE_URL}/nodes?${params}`;

        const response = await fetch(url, {
            method: 'GET',
            headers: {
                'Accept': 'application/json',
                'Content-Type': 'application/json',
                'Authorization': `Bearer ${API_TOKEN}`
            }
        });

        if (!response.ok) {
            throw new Error(`HTTP ${response.status}: ${response.statusText}`);
        }

        const data = await response.json();
        return data;
    } catch (error) {
        console.error('Error fetching project nodes:', error);
        throw error;
    }
}

// Example usage (only runs when executed directly)
if (typeof require !== 'undefined' && require.main === module) {
    // Example: Get nodes for project ID 1
    listProjectNodes(1, 1, 10)
        .then(result => {
            console.log('Project Nodes:');
            console.log(JSON.stringify(result, null, 2));
        })
        .catch(error => {
            console.error('Failed to fetch project nodes:', error.message);
        });
}

// Export for use in other modules
if (typeof module !== 'undefined' && module.exports) {
    module.exports = { listProjectNodes };
}

"""
TellsTree SDK - Nodes API (Python)
List all nodes in a project
"""

import requests
import json
from typing import Dict, Any, Optional

API_BASE_URL = "https://tellstree.com/api"
API_TOKEN = "your_jwt_token_here"

def list_project_nodes(project_id: int, page: int = 1, per_page: int = 20) -> Dict[str, Any]:
    """
    Get all nodes for a specific project
    
    Args:
        project_id (int): The ID of the project
        page (int): Page number (default: 1)
        per_page (int): Items per page (default: 10)
        
    Returns:
        Dict[str, Any]: API response with nodes data
        
    Raises:
        requests.RequestException: If the API request fails
        ValueError: If the response cannot be parsed as JSON
    """
    try:
        url = f"{API_BASE_URL}/nodes"
        params = {
            'query[project_id]': project_id,
            'query[page]': page,
            'query[per_page]': per_page
        }
        
        headers = {
            'Accept': 'application/json',
            'Content-Type': 'application/json',
            'Authorization': f'Bearer {API_TOKEN}'
        }
        
        response = requests.get(url, params=params, headers=headers)
        response.raise_for_status()
        
        return response.json()
        
    except requests.RequestException as e:
        print(f"Error fetching project nodes: {e}")
        raise
    except json.JSONDecodeError as e:
        print(f"Error parsing JSON response: {e}")
        raise ValueError("Invalid JSON response from API")

def main():
    """Example usage of the nodes API"""
    try:
        # Get nodes for project ID 1
        result = list_project_nodes(1, 1, 10)
        print("Project Nodes:")
        print(json.dumps(result, indent=2))
        
    except Exception as e:
        print(f"Failed to fetch project nodes: {e}")

if __name__ == "__main__":
    main()

<?php
/**
 * TellsTree SDK - Nodes API (PHP)
 * List all nodes in a project
 */

const API_BASE_URL = 'https://tellstree.com/api';
const API_TOKEN = 'your_jwt_token_here';

/**
 * Get all nodes for a specific project
 * 
 * @param int $projectId The ID of the project
 * @param int $page Page number (default: 1)
 * @param int $perPage Items per page (default: 10)
 * @return array API response with nodes data
 * @throws Exception If the API request fails
 */
function listProjectNodes($projectId, $page = 1, $perPage = 20) {
    $url = API_BASE_URL . "/nodes?" . http_build_query([
        'query' => [
            'project_id' => $projectId,
            'page' => $page,
            'per_page' => $perPage
        ]
    ]);
    
    $context = stream_context_create([
        'http' => [
            'method' => 'GET',
            'header' => [
                'Accept: application/json',
                'Content-Type: application/json',
                'Authorization: Bearer ' . API_TOKEN
            ],
            'ignore_errors' => true
        ]
    ]);
    
    $response = file_get_contents($url, false, $context);
    
    if ($response === false) {
        throw new Exception('Failed to make API request');
    }
    
    // Get HTTP status code
    $statusLine = $http_response_header[0] ?? '';
    preg_match('/\d{3}/', $statusLine, $matches);
    $statusCode = $matches[0] ?? 0;
    
    if ($statusCode >= 400) {
        $errorData = json_decode($response, true);
        $message = $errorData['message'] ?? 'HTTP Error ' . $statusCode;
        throw new Exception($message, (int)$statusCode);
    }
    
    $data = json_decode($response, true);
    
    if (json_last_error() !== JSON_ERROR_NONE) {
        throw new Exception('Invalid JSON response: ' . json_last_error_msg());
    }
    
    return $data;
}

// Example usage (only runs when executed directly)
if (basename(__FILE__) === basename($_SERVER['SCRIPT_FILENAME'])) {
    try {
        // Get nodes for project ID 1
        $result = listProjectNodes(1, 1, 10);
        echo "Project Nodes:\n";
        echo json_encode($result, JSON_PRETTY_PRINT) . "\n";
        
    } catch (Exception $e) {
        echo "Failed to fetch project nodes: " . $e->getMessage() . "\n";
        exit(1);
    }
}
?>

curl -X GET "https://tellstree.com/api/projects/1/nodes?page=1&per_page=10" \
     -H "Authorization: Bearer your-jwt-token" \
     -H "Accept: application/json"

{
    "method": "GET",
    "url": "http://localhost:8000/api/nodes",
    "headers": {
        "Authorization": [
            "***REDACTED***"
        ],
        "Accept": "application/json",
        "Content-Type": "application/json"
    },
    "payload": {
        "query": {
            "project_id": 1,
            "include": "1,2,3"
        }
    },
    "recorded_at": "2025-10-17T22:41:35+00:00"
}

// TellsTree SDK - Nodes API (JavaScript)
// Load specific nodes for lazy loading

const API_BASE_URL = 'https://tellstree.com/api';
const API_TOKEN = 'your_jwt_token_here';

/**
 * Load specific nodes by IDs for lazy loading
 * @param {number} projectId - The ID of the project
 * @param {Array<number|string>} nodeIds - Array of node IDs to load
 * @returns {Promise<Array>} Array of canvas-ready node objects
 */
async function loadSpecificNodes(projectId, nodeIds) {
    try {
        const params = new URLSearchParams({
            'query[project_id]': projectId,
            'query[include]': nodeIds.join(',')
        });
        const url = `${API_BASE_URL}/nodes?${params}`;

        const response = await fetch(url, {
            method: 'GET',
            headers: {
                'Accept': 'application/json',
                'Authorization': `Bearer ${API_TOKEN}`
            }
        });

        if (!response.ok) {
            throw new Error(`HTTP ${response.status}: ${response.statusText}`);
        }

        const data = await response.json();
        return data.data.nodes; // Extract nodes from wrapper structure
    } catch (error) {
        console.error('Failed to load nodes:', error);
        throw error;
    }
}

// Example usage (only runs when executed directly)
if (typeof require !== 'undefined' && require.main === module) {
    // Example: Load specific nodes for project 42
    const projectId = 42;
    const nodeIds = [1, 2, 3, 15, 28];
    
    loadSpecificNodes(projectId, nodeIds)
        .then(nodes => {
            console.log(`Loaded ${nodes.length} nodes:`);
            nodes.forEach(node => {
                console.log(`- ${node.title} (ID: ${node.node_id})`);
            });
        })
        .catch(error => {
            console.error('Failed to load nodes:', error.message);
        });
}

export { loadSpecificNodes };

"""
TellsTree SDK - Nodes API (Python)
Load specific nodes for lazy loading
"""

import requests
from typing import List, Dict, Any, Union

API_BASE_URL = "https://tellstree.com/api"
API_TOKEN = "your_jwt_token_here"

def load_specific_nodes(project_id: int, node_ids: List[Union[int, str]]) -> List[Dict[str, Any]]:
    """
    Load specific nodes by IDs for lazy loading
    
    Args:
        project_id: The ID of the project
        node_ids: Array of node IDs to load
        
    Returns:
        List of canvas-ready node objects
        
    Raises:
        requests.RequestException: If the API request fails
    """
    headers = {
        "Authorization": f"Bearer {API_TOKEN}",
        "Accept": "application/json"
    }
    
    params = {
        "query[project_id]": project_id,
        "query[include]": ",".join(map(str, node_ids))
    }
    
    response = requests.get(
        f"{API_BASE_URL}/nodes",
        headers=headers,
        params=params
    )
    
    response.raise_for_status()
    data = response.json()
    return data["data"]["nodes"]  # Extract nodes from wrapper structure

def main():
    """Example usage of the load specific nodes API"""
    try:
        # Example: Load specific nodes for project 42
        project_id = 42
        node_ids = [1, 2, 3, 15, 28]
        
        nodes = load_specific_nodes(project_id, node_ids)
        
        print(f"Loaded {len(nodes)} nodes:")
        for node in nodes:
            print(f"- {node['title']} (ID: {node['node_id']})")
            
    except requests.RequestException as e:
        print(f"Error: {e}")

if __name__ == "__main__":
    main()

<?php
/**
 * TellsTree SDK - Nodes API (PHP)
 * Load specific nodes for lazy loading
 */

const API_BASE_URL = 'https://tellstree.com/api';
const API_TOKEN = 'your_jwt_token_here';

/**
 * Load specific nodes by IDs for lazy loading
 * 
 * @param int $projectId The ID of the project
 * @param array $nodeIds Array of node IDs to load
 * @return array Array of canvas-ready node data
 * @throws Exception If the API request fails
 */
function loadSpecificNodes($projectId, $nodeIds) {
    $url = API_BASE_URL . "/nodes?" . http_build_query([
        'query' => [
            'project_id' => $projectId,
            'include' => implode(',', $nodeIds)
        ]
    ]);
    
    $context = stream_context_create([
        'http' => [
            'method' => 'GET',
            'header' => [
                'Accept: application/json',
                'Authorization: Bearer ' . API_TOKEN
            ]
        ]
    ]);
    
    $response = @file_get_contents($url, false, $context);
    
    if ($response === false) {
        $error = error_get_last();
        throw new Exception("API request failed: " . $error['message']);
    }
    
    $httpStatus = null;
    if (isset($http_response_header)) {
        foreach ($http_response_header as $header) {
            if (strpos($header, 'HTTP/') === 0) {
                preg_match('/HTTP\/\d\.\d (\d+)/', $header, $matches);
                if ($matches) {
                    $httpStatus = (int)$matches[1];
                    break;
                }
            }
        }
    }
    
    if ($httpStatus && $httpStatus >= 400) {
        throw new Exception("API request failed with HTTP $httpStatus");
    }
    
    $data = json_decode($response, true);
    
    if ($data === null) {
        throw new Exception("Invalid JSON response from API");
    }
    
    return $data['data']['nodes']; // Extract nodes from wrapper structure
}

// Example usage
if (__FILE__ == $_SERVER['SCRIPT_FILENAME']) {
    try {
        // Example: Load specific nodes for project 42
        $projectId = 42;
        $nodeIds = [1, 2, 3, 15, 28];
        
        $nodes = loadSpecificNodes($projectId, $nodeIds);
        
        echo "Loaded " . count($nodes) . " nodes:\n";
        foreach ($nodes as $node) {
            echo "- {$node['title']} (ID: {$node['node_id']})\n";
        }
    } catch (Exception $e) {
        echo "Error: " . $e->getMessage() . "\n";
    }
}
?>

# TellsTree Nodes API - Load Specific Nodes (cURL)
# 
# This example demonstrates how to load specific nodes by IDs
# for lazy loading in the TellsTreeGraph editor.

# Load specific nodes by IDs with query parameters
curl -X GET "https://tellstree.com/api/nodes?query%5Bproject_id%5D=42&query%5Binclude%5D=1,2,3,15,28" \
     -H "Authorization: Bearer your-jwt-token" \
     -H "Accept: application/json"

# Alternative: Using -G and -d for more readable format
curl -G \
     -H "Authorization: Bearer your-jwt-token" \
     -H "Accept: application/json" \
     -d "query[project_id]=42" \
     -d "query[include]=1,2,3,15,28" \
     "https://tellstree.com/api/nodes"

# Expected response: Array of canvas-ready node objects
# [
#   {
#     "node_id": 1,
#     "title": "Main Character",
#     "x_position": 100,
#     "y_position": 200,
#     "type": "character",
#     "resolved": {
#       "content": "...",
#       "media": []
#     }
#   }
# ]

{
    "method": "POST",
    "url": "http://localhost:8000/api/nodes",
    "headers": {
        "Authorization": [
            "***REDACTED***"
        ],
        "Accept": "application/json",
        "Content-Type": "application/json"
    },
    "payload": {
        "type": "character",
        "label": "API Test Character 1760740894",
        "content": {
            "name": "API Test Character 1760740894",
            "description": "Node created by automated API test"
        },
        "media": [],
        "project_id": 92
    },
    "recorded_at": "2025-10-17T22:41:34+00:00"
}

// TellsTree SDK - Nodes API (JavaScript)
// Create a new node

const API_BASE_URL = 'https://tellstree.com/api';
const API_TOKEN = 'your_jwt_token_here';

/**
 * Create a new node
 * @param {Object} nodeData - The node data
 * @param {string} nodeData.type - Node type (e.g., 'character', 'scene', 'chapter')
 * @param {string} nodeData.label - Node label/title
 * @param {Object} nodeData.content - Node content object
 * @param {number} [nodeData.project_id] - Optional project ID to associate with
 * @param {Array} [nodeData.media] - Optional media array
 * @returns {Promise<Object>} API response with created node data
 */
async function createNode(nodeData) {
    try {
        const response = await fetch(`${API_BASE_URL}/nodes`, {
            method: 'POST',
            headers: {
                'Accept': 'application/json',
                'Content-Type': 'application/json',
                'Authorization': `Bearer ${API_TOKEN}`
            },
            body: JSON.stringify(nodeData)
        });

        if (!response.ok) {
            throw new Error(`HTTP ${response.status}: ${response.statusText}`);
        }

        const data = await response.json();
        return data;

    } catch (error) {
        console.error('Error creating node:', error);
        throw error;
    }
}

// Example usage
const newNodeData = {
    type: 'character',
    label: 'My New Character',
    content: {
        name: 'Hero Character',
        description: 'The main protagonist of our story'
    },
    media: [],
    project_id: 1 // Optional - associate with a project
};

createNode(newNodeData)
    .then(result => {
        console.log('Node created successfully:', result.data.node);
    })
    .catch(error => {
        console.error('Failed to create node:', error);
    });

# TellsTree SDK - Nodes API (Python)
# Create a new node

import requests
import json

API_BASE_URL = 'https://tellstree.com/api'
API_TOKEN = 'your_jwt_token_here'

def create_node(node_data):
    """
    Create a new node
    
    Args:
        node_data (dict): The node data
            - type (str): Node type (e.g., 'character', 'scene', 'chapter')
            - label (str): Node label/title
            - content (dict): Node content object
            - project_id (int, optional): Optional project ID to associate with
            - media (list, optional): Optional media array
    
    Returns:
        dict: API response with created node data
    """
    try:
        headers = {
            'Accept': 'application/json',
            'Content-Type': 'application/json',
            'Authorization': f'Bearer {API_TOKEN}'
        }
        
        response = requests.post(
            f'{API_BASE_URL}/nodes',
            headers=headers,
            json=node_data,
            timeout=30
        )
        
        response.raise_for_status()
        return response.json()
        
    except requests.exceptions.RequestException as e:
        print(f'Error creating node: {e}')
        raise e

# Example usage
if __name__ == '__main__':
    new_node_data = {
        'type': 'character',
        'label': 'My New Character',
        'content': {
            'name': 'Hero Character',
            'description': 'The main protagonist of our story'
        },
        'media': [],
        'project_id': 1  # Optional - associate with a project
    }
    
    try:
        result = create_node(new_node_data)
        print('Node created successfully:', result['data']['node'])
    except Exception as error:
        print('Failed to create node:', error)

<?php
/**
 * TellsTree SDK - Nodes API (PHP)
 * Create a new node
 */

const API_BASE_URL = 'https://tellstree.com/api';
const API_TOKEN = 'your_jwt_token_here';

/**
 * Create a new node
 * 
 * @param array $nodeData The node data
 *                        - type (string): Node type (e.g., 'character', 'scene', 'chapter')
 *                        - label (string): Node label/title
 *                        - content (array): Node content object
 *                        - project_id (int, optional): Optional project ID to associate with
 *                        - media (array, optional): Optional media array
 * @return array API response with created node data
 * @throws Exception If the request fails
 */
function createNode($nodeData) {
    $url = API_BASE_URL . '/nodes';
    
    $headers = [
        'Accept: application/json',
        'Content-Type: application/json',
        'Authorization: Bearer ' . API_TOKEN
    ];
    
    $context = stream_context_create([
        'http' => [
            'method' => 'POST',
            'header' => implode("\r\n", $headers),
            'content' => json_encode($nodeData)
        ]
    ]);
    
    $response = file_get_contents($url, false, $context);
    
    if ($response === false) {
        throw new Exception('Failed to create node: Unable to connect to API');
    }
    
    $data = json_decode($response, true);
    
    if (json_last_error() !== JSON_ERROR_NONE) {
        throw new Exception('Failed to decode JSON response: ' . json_last_error_msg());
    }
    
    return $data;
}

// Example usage
try {
    $newNodeData = [
        'type' => 'character',
        'label' => 'My New Character',
        'content' => [
            'name' => 'Hero Character',
            'description' => 'The main protagonist of our story'
        ],
        'media' => [],
        'project_id' => 1 // Optional - associate with a project
    ];
    
    $result = createNode($newNodeData);
    echo "Node created successfully:\n";
    print_r($result['data']['node']);
    
} catch (Exception $error) {
    echo "Failed to create node: " . $error->getMessage() . "\n";
}
?>

#!/bin/bash

# TellsTree SDK - Nodes API (cURL)
# Create a new node

API_BASE_URL="https://tellstree.com/api"
API_TOKEN="your_jwt_token_here"

# Create a new node
curl -X POST "${API_BASE_URL}/nodes" \
  -H "Accept: application/json" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer ${API_TOKEN}" \
  -d '{
    "type": "character",
    "label": "My New Character",
    "content": {
      "name": "Hero Character", 
      "description": "The main protagonist of our story"
    },
    "media": [],
    "project_id": 1
  }'

{
    "method": "GET",
    "url": "http://localhost:8000/api/nodes",
    "headers": {
        "Authorization": [
            "***REDACTED***"
        ],
        "Accept": "application/json",
        "Content-Type": "application/json"
    },
    "payload": {
        "query": {
            "project_id": 1
        }
    },
    "recorded_at": "2025-10-17T22:41:35+00:00"
}

// TellsTree SDK - Nodes API (JavaScript)  
// Get specific node details

const API_BASE_URL = 'https://tellstree.com/api';
const API_TOKEN = 'your_jwt_token_here';

/**
 * Get a specific node by ID
 * @param {number} nodeId - The ID of the node to retrieve
 * @returns {Promise<Object>} API response with node data
 */
async function getNode(nodeId) {
    try {
        const response = await fetch(`${API_BASE_URL}/nodes/${nodeId}`, {
            method: 'GET',
            headers: {
                'Accept': 'application/json',
                'Content-Type': 'application/json',
                'Authorization': `Bearer ${API_TOKEN}`
            }
        });

        if (!response.ok) {
            throw new Error(`HTTP ${response.status}: ${response.statusText}`);
        }

        const data = await response.json();
        return data;
    } catch (error) {
        console.error('Error fetching node:', error);
        throw error;
    }
}

/**
 * Create a new node in a project
 * @param {Object} nodeData - The node data to create
 * @returns {Promise<Object>} API response with created node
 */
async function createNode(nodeData) {
    try {
        const response = await fetch(`${API_BASE_URL}/nodes`, {
            method: 'POST',
            headers: {
                'Accept': 'application/json',
                'Content-Type': 'application/json',
                'Authorization': `Bearer ${API_TOKEN}`
            },
            body: JSON.stringify(nodeData)
        });

        if (!response.ok) {
            throw new Error(`HTTP ${response.status}: ${response.statusText}`);
        }

        const data = await response.json();
        return data;
    } catch (error) {
        console.error('Error creating node:', error);
        throw error;
    }
}

// Example usage (only runs when executed directly)
if (typeof require !== 'undefined' && require.main === module) {
    // Example: Get node with ID 1
    getNode(1)
        .then(result => {
            console.log('Node Details:');
            console.log(JSON.stringify(result, null, 2));
        })
        .catch(error => {
            console.error('Failed to fetch node:', error.message);
        });

    // Example: Create a new node
    const newNode = {
        project_id: 1,
        title: "New Story Node",
        content: "This is the content of the new node.",
        type: "dialogue",
        position_x: 100,
        position_y: 200
    };

    createNode(newNode)
        .then(result => {
            console.log('Created Node:');
            console.log(JSON.stringify(result, null, 2));
        })
        .catch(error => {
            console.error('Failed to create node:', error.message);
        });
}

// Export for use in other modules
if (typeof module !== 'undefined' && module.exports) {
    module.exports = { getNode, createNode };
}

"""
TellsTree SDK - Nodes API (Python)
Get specific node details and create new nodes
"""

import requests
import json
from typing import Dict, Any, Optional

API_BASE_URL = "https://tellstree.com/api"
API_TOKEN = "your_jwt_token_here"

def get_node(node_id: int) -> Dict[str, Any]:
    """
    Get a specific node by ID
    
    Args:
        node_id (int): The ID of the node to retrieve
        
    Returns:
        Dict[str, Any]: API response with node data
        
    Raises:
        requests.RequestException: If the API request fails
        ValueError: If the response cannot be parsed as JSON
    """
    try:
        url = f"{API_BASE_URL}/nodes/{node_id}"
        
        headers = {
            'Accept': 'application/json',
            'Content-Type': 'application/json',
            'Authorization': f'Bearer {API_TOKEN}'
        }
        
        response = requests.get(url, headers=headers)
        response.raise_for_status()
        
        return response.json()
        
    except requests.RequestException as e:
        print(f"Error fetching node: {e}")
        raise
    except json.JSONDecodeError as e:
        print(f"Error parsing JSON response: {e}")
        raise ValueError("Invalid JSON response from API")

def create_node(node_data: Dict[str, Any]) -> Dict[str, Any]:
    """
    Create a new node in a project
    
    Args:
        node_data (Dict[str, Any]): The node data to create
        
    Returns:
        Dict[str, Any]: API response with created node
        
    Raises:
        requests.RequestException: If the API request fails
        ValueError: If the response cannot be parsed as JSON
    """
    try:
        url = f"{API_BASE_URL}/nodes"
        
        headers = {
            'Accept': 'application/json',
            'Content-Type': 'application/json',
            'Authorization': f'Bearer {API_TOKEN}'
        }
        
        response = requests.post(url, headers=headers, json=node_data)
        response.raise_for_status()
        
        return response.json()
        
    except requests.RequestException as e:
        print(f"Error creating node: {e}")
        raise
    except json.JSONDecodeError as e:
        print(f"Error parsing JSON response: {e}")
        raise ValueError("Invalid JSON response from API")

def main():
    """Example usage of the nodes API"""
    try:
        # Get node with ID 1
        result = get_node(1)
        print("Node Details:")
        print(json.dumps(result, indent=2))
        
        # Create a new node
        new_node = {
            "project_id": 1,
            "title": "New Story Node",
            "content": "This is the content of the new node.",
            "type": "dialogue",
            "position_x": 100,
            "position_y": 200
        }
        
        created_node = create_node(new_node)
        print("\nCreated Node:")
        print(json.dumps(created_node, indent=2))
        
    except Exception as e:
        print(f"Failed to process nodes: {e}")

if __name__ == "__main__":
    main()

<?php
/**
 * TellsTree SDK - Nodes API (PHP)
 * Get specific node details and create new nodes
 */

const API_BASE_URL = 'https://tellstree.com/api';
const API_TOKEN = 'your_jwt_token_here';

/**
 * Get a specific node by ID
 * 
 * @param int $nodeId The ID of the node to retrieve
 * @return array API response with node data
 * @throws Exception If the API request fails
 */
function getNode($nodeId) {
    $url = API_BASE_URL . "/nodes/{$nodeId}";
    
    $context = stream_context_create([
        'http' => [
            'method' => 'GET',
            'header' => [
                'Accept: application/json',
                'Content-Type: application/json',
                'Authorization: Bearer ' . API_TOKEN
            ],
            'ignore_errors' => true
        ]
    ]);
    
    $response = file_get_contents($url, false, $context);
    
    if ($response === false) {
        throw new Exception('Failed to make API request');
    }
    
    // Get HTTP status code
    $statusLine = $http_response_header[0] ?? '';
    preg_match('/\d{3}/', $statusLine, $matches);
    $statusCode = $matches[0] ?? 0;
    
    if ($statusCode >= 400) {
        $errorData = json_decode($response, true);
        $message = $errorData['message'] ?? 'HTTP Error ' . $statusCode;
        throw new Exception($message, (int)$statusCode);
    }
    
    $data = json_decode($response, true);
    
    if (json_last_error() !== JSON_ERROR_NONE) {
        throw new Exception('Invalid JSON response: ' . json_last_error_msg());
    }
    
    return $data;
}

/**
 * Create a new node in a project
 * 
 * @param array $nodeData The node data to create
 * @return array API response with created node
 * @throws Exception If the API request fails
 */
function createNode($nodeData) {
    $url = API_BASE_URL . "/nodes";
    $jsonData = json_encode($nodeData);
    
    $context = stream_context_create([
        'http' => [
            'method' => 'POST',
            'header' => [
                'Accept: application/json',
                'Content-Type: application/json',
                'Authorization: Bearer ' . API_TOKEN,
                'Content-Length: ' . strlen($jsonData)
            ],
            'content' => $jsonData,
            'ignore_errors' => true
        ]
    ]);
    
    $response = file_get_contents($url, false, $context);
    
    if ($response === false) {
        throw new Exception('Failed to make API request');
    }
    
    // Get HTTP status code
    $statusLine = $http_response_header[0] ?? '';
    preg_match('/\d{3}/', $statusLine, $matches);
    $statusCode = $matches[0] ?? 0;
    
    if ($statusCode >= 400) {
        $errorData = json_decode($response, true);
        $message = $errorData['message'] ?? 'HTTP Error ' . $statusCode;
        throw new Exception($message, (int)$statusCode);
    }
    
    $data = json_decode($response, true);
    
    if (json_last_error() !== JSON_ERROR_NONE) {
        throw new Exception('Invalid JSON response: ' . json_last_error_msg());
    }
    
    return $data;
}

// Example usage (only runs when executed directly)
if (basename(__FILE__) === basename($_SERVER['SCRIPT_FILENAME'])) {
    try {
        // Get node with ID 1
        $result = getNode(1);
        echo "Node Details:\n";
        echo json_encode($result, JSON_PRETTY_PRINT) . "\n";
        
        // Create a new node
        $newNode = [
            'project_id' => 1,
            'title' => 'New Story Node',
            'content' => 'This is the content of the new node.',
            'type' => 'dialogue',
            'position_x' => 100,
            'position_y' => 200
        ];
        
        $createdNode = createNode($newNode);
        echo "\nCreated Node:\n";
        echo json_encode($createdNode, JSON_PRETTY_PRINT) . "\n";
        
    } catch (Exception $e) {
        echo "Failed to process nodes: " . $e->getMessage() . "\n";
        exit(1);
    }
}
?>

curl -X GET "https://tellstree.com/api/nodes/1" \
     -H "Authorization: Bearer your-jwt-token" \
     -H "Accept: application/json"

{
    "method": "PUT",
    "url": "http://localhost:8000/api/nodes/336",
    "headers": {
        "Authorization": [
            "***REDACTED***"
        ],
        "Accept": "application/json",
        "Content-Type": "application/json"
    },
    "payload": {
        "type": "character",
        "content": {
            "name": "Updated API Test Character"
        },
        "is_locked": true
    },
    "recorded_at": "2025-10-17T22:41:35+00:00"
}

// TellsTree SDK - Nodes API (JavaScript)
// Update an existing node

const API_BASE_URL = 'https://tellstree.com/api';
const API_TOKEN = 'your_jwt_token_here';

/**
 * Update an existing node
 * @param {number} nodeId - The ID of the node to update
 * @param {Object} updateData - The update data
 * @param {string} updateData.type - Node type (required)
 * @param {Object} [updateData.content] - Updated content object
 * @param {string} [updateData.label] - Updated label/title
 * @param {Array} [updateData.media] - Updated media array
 * @param {boolean} [updateData.is_locked] - Lock state (true to lock, false to unlock)
 * @returns {Promise<Object>} API response with updated node data
 */
async function updateNode(nodeId, updateData) {
    try {
        const response = await fetch(`${API_BASE_URL}/nodes/${nodeId}`, {
            method: 'PUT',
            headers: {
                'Accept': 'application/json',
                'Content-Type': 'application/json',
                'Authorization': `Bearer ${API_TOKEN}`
            },
            body: JSON.stringify(updateData)
        });

        if (!response.ok) {
            throw new Error(`HTTP ${response.status}: ${response.statusText}`);
        }

        const data = await response.json();
        return data;

    } catch (error) {
        console.error('Error updating node:', error);
        throw error;
    }
}

// Example usage
const nodeId = 1; // Replace with actual node ID
const updateData = {
    type: 'character', // Required field
    content: {
        name: 'Updated Character Name',
        description: 'Updated character description'
    },
    is_locked: true // Optional: Lock for current user, or false to unlock
};

updateNode(nodeId, updateData)
    .then(result => {
        console.log('Node updated successfully:', result.data.node);
    })
    .catch(error => {
        console.error('Failed to update node:', error);
    });

# TellsTree SDK - Nodes API (Python)
# Update an existing node

import requests
import json

API_BASE_URL = 'https://tellstree.com/api'
API_TOKEN = 'your_jwt_token_here'

def update_node(node_id, update_data):
    """
    Update an existing node
    
    Args:
        node_id (int): The ID of the node to update
        update_data (dict): The update data
            - type (str): Node type (required)
            - content (dict, optional): Updated content object
            - label (str, optional): Updated label/title
            - media (list, optional): Updated media array
    
    Returns:
        dict: API response with updated node data
    """
    try:
        headers = {
            'Accept': 'application/json',
            'Content-Type': 'application/json',
            'Authorization': f'Bearer {API_TOKEN}'
        }
        
        response = requests.put(
            f'{API_BASE_URL}/nodes/{node_id}',
            headers=headers,
            json=update_data,
            timeout=30
        )
        
        response.raise_for_status()
        return response.json()
        
    except requests.exceptions.RequestException as e:
        print(f'Error updating node: {e}')
        raise e

# Example usage
if __name__ == '__main__':
    node_id = 1  # Replace with actual node ID
    update_data = {
        'type': 'character',  # Required field
        'content': {
            'name': 'Updated Character Name',
            'description': 'Updated character description'
        }
    }
    
    try:
        result = update_node(node_id, update_data)
        print('Node updated successfully:', result['data']['node'])
    except Exception as error:
        print('Failed to update node:', error)

<?php
/**
 * TellsTree SDK - Nodes API (PHP)
 * Update an existing node
 */

const API_BASE_URL = 'https://tellstree.com/api';
const API_TOKEN = 'your_jwt_token_here';

/**
 * Update an existing node
 * 
 * @param int $nodeId The ID of the node to update
 * @param array $updateData The update data
 *                          - type (string): Node type (required)
 *                          - content (array, optional): Updated content object
 *                          - label (string, optional): Updated label/title
 *                          - media (array, optional): Updated media array
 *                          - is_locked (bool, optional): Lock state (true to lock, false to unlock)
 * @return array API response with updated node data
 * @throws Exception If the request fails
 */
function updateNode($nodeId, $updateData) {
    $url = API_BASE_URL . '/nodes/' . $nodeId;
    
    $headers = [
        'Accept: application/json',
        'Content-Type: application/json',
        'Authorization: Bearer ' . API_TOKEN
    ];
    
    $context = stream_context_create([
        'http' => [
            'method' => 'PUT',
            'header' => implode("\r\n", $headers),
            'content' => json_encode($updateData)
        ]
    ]);
    
    $response = file_get_contents($url, false, $context);
    
    if ($response === false) {
        throw new Exception('Failed to update node: Unable to connect to API');
    }
    
    $data = json_decode($response, true);
    
    if (json_last_error() !== JSON_ERROR_NONE) {
        throw new Exception('Failed to decode JSON response: ' . json_last_error_msg());
    }
    
    return $data;
}

// Example usage
try {
    $nodeId = 1; // Replace with actual node ID
    $updateData = [
        'type' => 'character', // Required field
        'content' => [
            'name' => 'Updated Character Name',
            'description' => 'Updated character description'
        ],
        'is_locked' => true // Optional: Lock for current user, or false to unlock
    ];
    
    $result = updateNode($nodeId, $updateData);
    echo "Node updated successfully:\n";
    print_r($result['data']['node']);
    
} catch (Exception $error) {
    echo "Failed to update node: " . $error->getMessage() . "\n";
}
?>

#!/bin/bash

# TellsTree SDK - Nodes API (cURL)
# Update an existing node

API_BASE_URL="https://tellstree.com/api"
API_TOKEN="your_jwt_token_here"
NODE_ID="1" # Replace with actual node ID

# Update an existing node
curl -X PUT "${API_BASE_URL}/nodes/${NODE_ID}" \
  -H "Accept: application/json" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer ${API_TOKEN}" \
  -d '{
    "type": "character",
    "content": {
      "name": "Updated Character Name",
      "description": "Updated character description"
    }
  }'

{
    "method": "DELETE",
    "url": "http://localhost:8000/api/nodes/336",
    "headers": {
        "Authorization": [
            "***REDACTED***"
        ],
        "Accept": "application/json",
        "Content-Type": "application/json"
    },
    "payload": null,
    "recorded_at": "2025-10-17T22:41:35+00:00"
}

// TellsTree SDK - Nodes API (JavaScript)
// Delete a node

const API_BASE_URL = 'https://tellstree.com/api';
const API_TOKEN = 'your_jwt_token_here';

/**
 * Delete a node permanently
 * @param {number} nodeId - The ID of the node to delete
 * @returns {Promise<boolean>} True if deletion was successful
 */
async function deleteNode(nodeId) {
    try {
        const response = await fetch(`${API_BASE_URL}/nodes/${nodeId}`, {
            method: 'DELETE',
            headers: {
                'Accept': 'application/json',
                'Content-Type': 'application/json',
                'Authorization': `Bearer ${API_TOKEN}`
            }
        });

        if (response.status === 204) {
            return true; // Successfully deleted (No Content)
        } else if (!response.ok) {
            throw new Error(`HTTP ${response.status}: ${response.statusText}`);
        }

        return true;

    } catch (error) {
        console.error('Error deleting node:', error);
        throw error;
    }
}

// Example usage
const nodeId = 1; // Replace with actual node ID

deleteNode(nodeId)
    .then(success => {
        if (success) {
            console.log('Node deleted successfully');
        }
    })
    .catch(error => {
        console.error('Failed to delete node:', error);
    });

# TellsTree SDK - Nodes API (Python)
# Delete a node

import requests

API_BASE_URL = 'https://tellstree.com/api'
API_TOKEN = 'your_jwt_token_here'

def delete_node(node_id):
    """
    Delete a node permanently
    
    Args:
        node_id (int): The ID of the node to delete
    
    Returns:
        bool: True if deletion was successful
    """
    try:
        headers = {
            'Accept': 'application/json',
            'Content-Type': 'application/json',
            'Authorization': f'Bearer {API_TOKEN}'
        }
        
        response = requests.delete(
            f'{API_BASE_URL}/nodes/{node_id}',
            headers=headers,
            timeout=30
        )
        
        if response.status_code == 204:
            return True  # Successfully deleted (No Content)
        else:
            response.raise_for_status()
            return True
        
    except requests.exceptions.RequestException as e:
        print(f'Error deleting node: {e}')
        raise e

# Example usage
if __name__ == '__main__':
    node_id = 1  # Replace with actual node ID
    
    try:
        success = delete_node(node_id)
        if success:
            print('Node deleted successfully')
    except Exception as error:
        print('Failed to delete node:', error)

<?php
$projectId = 42;
$nodeId = 123;
$token = "your-auth-token";

$context = stream_context_create([
    "http" => [
        "method" => "DELETE",
        "header" => [
            "Authorization: Bearer $token",
            "Accept: application/json"
        ]
    ]
]);

$response = file_get_contents(
    "https://tellstree.com/api/projects/$projectId/nodes/$nodeId",
    false,
    $context
);

$result = json_decode($response);
var_dump($result);
?>

curl -X DELETE "https://tellstree.com/api/projects/42/nodes/123" \
     -H "Authorization: Bearer your-auth-token" \
     -H "Accept: application/json"

{
    "method": "POST",
    "url": "http://localhost:8000/api/edges",
    "headers": {
        "Authorization": [
            "***REDACTED***"
        ],
        "Accept": "application/json",
        "Content-Type": "application/json"
    },
    "payload": {
        "from_node_id": 332,
        "to_node_id": 333,
        "type": "connection",
        "condition": null,
        "project_id": 91
    },
    "recorded_at": "2025-10-17T22:41:32+00:00"
}

// TellsTree SDK - Edges API (JavaScript)
// Create a new edge connection between nodes

const API_BASE_URL = 'https://tellstree.com/api';
const API_TOKEN = 'your_jwt_token_here';

/**
 * Create a new edge connection between two nodes
 * @param {Object} edgeData - The edge data
 * @param {number} edgeData.from_node_id - ID of the source node
 * @param {number} edgeData.to_node_id - ID of the target node
 * @param {string} [edgeData.type] - Edge type (e.g., 'connection')
 * @param {string} [edgeData.condition] - Edge activation condition
 * @param {number} [edgeData.project_id] - Optional project ID to associate with
 * @returns {Promise<Object>} API response with created edge data
 */
async function createEdge(edgeData) {
    try {
        const response = await fetch(`${API_BASE_URL}/edges`, {
            method: 'POST',
            headers: {
                'Accept': 'application/json',
                'Content-Type': 'application/json',
                'Authorization': `Bearer ${API_TOKEN}`
            },
            body: JSON.stringify(edgeData)
        });

        if (!response.ok) {
            throw new Error(`HTTP ${response.status}: ${response.statusText}`);
        }

        const data = await response.json();
        return data;

    } catch (error) {
        console.error('Error creating edge:', error);
        throw error;
    }
}

// Example usage
const newEdgeData = {
    from_node_id: 1,
    to_node_id: 2,
    type: 'connection',
    condition: null,
    project_id: 1 // Optional
};

createEdge(newEdgeData)
    .then(result => {
        console.log('Edge created successfully:', result.data.edge);
    })
    .catch(error => {
        console.error('Failed to create edge:', error);
    });

# TellsTree SDK - Edges API (Python)
# Create a new edge connection between nodes

import requests
import json

API_BASE_URL = 'https://tellstree.com/api'
API_TOKEN = 'your_jwt_token_here'

def create_edge(edge_data):
    """
    Create a new edge connection between two nodes
    
    Args:
        edge_data (dict): The edge data
            - from_node_id (int): ID of the source node
            - to_node_id (int): ID of the target node
            - type (str, optional): Edge type (e.g., 'connection')
            - condition (str, optional): Edge activation condition
            - project_id (int, optional): Optional project ID to associate with
    
    Returns:
        dict: API response with created edge data
    """
    try:
        headers = {
            'Accept': 'application/json',
            'Content-Type': 'application/json',
            'Authorization': f'Bearer {API_TOKEN}'
        }
        
        response = requests.post(
            f'{API_BASE_URL}/edges',
            headers=headers,
            json=edge_data,
            timeout=30
        )
        
        response.raise_for_status()
        return response.json()
        
    except requests.exceptions.RequestException as e:
        print(f'Error creating edge: {e}')
        raise e

# Example usage
if __name__ == '__main__':
    new_edge_data = {
        'from_node_id': 1,
        'to_node_id': 2,
        'type': 'connection',
        'condition': None,
        'project_id': 1  # Optional
    }
    
    try:
        result = create_edge(new_edge_data)
        print('Edge created successfully:', result['data']['edge'])
    except Exception as error:
        print('Failed to create edge:', error)

<?php
/**
 * TellsTree SDK - Edges API (PHP)
 * Create a new edge connection between nodes
 */

const API_BASE_URL = 'https://tellstree.com/api';
const API_TOKEN = 'your_jwt_token_here';

/**
 * Create a new edge connection between two nodes
 * 
 * @param array $edgeData The edge data
 *                        - from_node_id (int): ID of the source node
 *                        - to_node_id (int): ID of the target node
 *                        - type (string, optional): Edge type (e.g., 'connection')
 *                        - condition (string, optional): Edge activation condition
 *                        - project_id (int, optional): Optional project ID to associate with
 * @return array API response with created edge data
 * @throws Exception If the request fails
 */
function createEdge($edgeData) {
    $url = API_BASE_URL . '/edges';
    
    $headers = [
        'Accept: application/json',
        'Content-Type: application/json',
        'Authorization: Bearer ' . API_TOKEN
    ];
    
    $context = stream_context_create([
        'http' => [
            'method' => 'POST',
            'header' => implode("\r\n", $headers),
            'content' => json_encode($edgeData)
        ]
    ]);
    
    $response = file_get_contents($url, false, $context);
    
    if ($response === false) {
        throw new Exception('Failed to create edge: Unable to connect to API');
    }
    
    $data = json_decode($response, true);
    
    if (json_last_error() !== JSON_ERROR_NONE) {
        throw new Exception('Failed to decode JSON response: ' . json_last_error_msg());
    }
    
    return $data;
}

// Example usage
try {
    $newEdgeData = [
        'from_node_id' => 1,
        'to_node_id' => 2,
        'type' => 'connection',
        'condition' => null,
        'project_id' => 1 // Optional
    ];
    
    $result = createEdge($newEdgeData);
    echo "Edge created successfully:\n";
    print_r($result['data']['edge']);
    
} catch (Exception $error) {
    echo "Failed to create edge: " . $error->getMessage() . "\n";
}
?>

#!/bin/bash

# TellsTree SDK - Edges API (cURL)
# Create a new edge connection between nodes

API_BASE_URL="https://tellstree.com/api"
API_TOKEN="your_jwt_token_here"

# Create a new edge
curl -X POST "${API_BASE_URL}/edges" \
  -H "Accept: application/json" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer ${API_TOKEN}" \
  -d '{
    "from_node_id": 1,
    "to_node_id": 2,
    "type": "connection",
    "condition": null,
    "project_id": 1
  }'

{
    "method": "GET",
    "url": "http://localhost:8000/api/edges/107",
    "headers": {
        "Authorization": [
            "***REDACTED***"
        ],
        "Accept": "application/json",
        "Content-Type": "application/json"
    },
    "payload": null,
    "recorded_at": "2025-10-17T22:41:32+00:00"
}

// TellsTree SDK - Edges API (JavaScript)
// Read/Get an edge

const API_BASE_URL = 'https://tellstree.com/api';
const API_TOKEN = 'your_jwt_token_here';

/**
 * Get detailed information about a specific edge
 * @param {number} edgeId - The ID of the edge to retrieve
 * @returns {Promise<Object>} API response with edge data
 */
async function getEdge(edgeId) {
    try {
        const response = await fetch(`${API_BASE_URL}/edges/${edgeId}`, {
            method: 'GET',
            headers: {
                'Accept': 'application/json',
                'Authorization': `Bearer ${API_TOKEN}`
            }
        });

        if (!response.ok) {
            throw new Error(`HTTP ${response.status}: ${response.statusText}`);
        }

        const data = await response.json();
        return data;

    } catch (error) {
        console.error('Error fetching edge:', error);
        throw error;
    }
}

// Example usage
const edgeId = 1; // Replace with actual edge ID

getEdge(edgeId)
    .then(result => {
        console.log('Edge details:', result.data.edge);
    })
    .catch(error => {
        console.error('Failed to fetch edge:', error);
    });

# TellsTree SDK - Edges API (Python)
# Read/Get an edge

import requests

API_BASE_URL = 'https://tellstree.com/api'
API_TOKEN = 'your_jwt_token_here'

def get_edge(edge_id):
    """
    Get detailed information about a specific edge
    
    Args:
        edge_id (int): The ID of the edge to retrieve
    
    Returns:
        dict: API response with edge data
    """
    try:
        headers = {
            'Accept': 'application/json',
            'Authorization': f'Bearer {API_TOKEN}'
        }
        
        response = requests.get(
            f'{API_BASE_URL}/edges/{edge_id}',
            headers=headers,
            timeout=30
        )
        
        response.raise_for_status()
        return response.json()
        
    except requests.exceptions.RequestException as e:
        print(f'Error fetching edge: {e}')
        raise e

# Example usage
if __name__ == '__main__':
    edge_id = 1  # Replace with actual edge ID
    
    try:
        result = get_edge(edge_id)
        print('Edge details:', result['data']['edge'])
    except Exception as error:
        print('Failed to fetch edge:', error)

<?php
/**
 * TellsTree SDK - Edges API (PHP)
 * Read/Get an edge
 */

const API_BASE_URL = 'https://tellstree.com/api';
const API_TOKEN = 'your_jwt_token_here';

/**
 * Get detailed information about a specific edge
 * 
 * @param int $edgeId The ID of the edge to retrieve
 * @return array API response with edge data
 * @throws Exception If the request fails
 */
function getEdge($edgeId) {
    $url = API_BASE_URL . '/edges/' . $edgeId;
    
    $headers = [
        'Accept: application/json',
        'Authorization: Bearer ' . API_TOKEN
    ];
    
    $context = stream_context_create([
        'http' => [
            'method' => 'GET',
            'header' => implode("\r\n", $headers)
        ]
    ]);
    
    $response = file_get_contents($url, false, $context);
    
    if ($response === false) {
        throw new Exception('Failed to fetch edge: Unable to connect to API');
    }
    
    $data = json_decode($response, true);
    
    if (json_last_error() !== JSON_ERROR_NONE) {
        throw new Exception('Failed to decode JSON response: ' . json_last_error_msg());
    }
    
    return $data;
}

// Example usage
try {
    $edgeId = 1; // Replace with actual edge ID
    
    $result = getEdge($edgeId);
    echo "Edge details:\n";
    print_r($result['data']['edge']);
    
} catch (Exception $error) {
    echo "Failed to fetch edge: " . $error->getMessage() . "\n";
}
?>

#!/bin/bash

# TellsTree SDK - Edges API (cURL)
# Read/Get an edge

API_BASE_URL="https://tellstree.com/api"
API_TOKEN="your_jwt_token_here"
EDGE_ID="1" # Replace with actual edge ID

# Get edge details
curl -X GET "${API_BASE_URL}/edges/${EDGE_ID}" \
  -H "Accept: application/json" \
  -H "Authorization: Bearer ${API_TOKEN}"

{
    "method": "PUT",
    "url": "http://localhost:8000/api/edges/107",
    "headers": {
        "Authorization": [
            "***REDACTED***"
        ],
        "Accept": "application/json",
        "Content-Type": "application/json"
    },
    "payload": {
        "from_node_id": 332,
        "to_node_id": 333,
        "type": "connection",
        "condition": "updated condition",
        "is_locked": true
    },
    "recorded_at": "2025-10-17T22:41:32+00:00"
}

// TellsTree SDK - Edges API (JavaScript)
// Update an existing edge

const API_BASE_URL = 'https://tellstree.com/api';
const API_TOKEN = 'your_jwt_token_here';

/**
 * Update an existing edge
 * @param {number} edgeId - The ID of the edge to update
 * @param {Object} updateData - The update data
 * @param {number} updateData.from_node_id - ID of the source node
 * @param {number} updateData.to_node_id - ID of the target node
 * @param {string} [updateData.type] - Edge type
 * @param {string} [updateData.condition] - Edge activation condition
 * @param {boolean} [updateData.is_locked] - Lock state (true to lock, false to unlock)
 * @returns {Promise<Object>} API response with updated edge data
 */
async function updateEdge(edgeId, updateData) {
    try {
        const response = await fetch(`${API_BASE_URL}/edges/${edgeId}`, {
            method: 'PUT',
            headers: {
                'Accept': 'application/json',
                'Content-Type': 'application/json',
                'Authorization': `Bearer ${API_TOKEN}`
            },
            body: JSON.stringify(updateData)
        });

        if (!response.ok) {
            throw new Error(`HTTP ${response.status}: ${response.statusText}`);
        }

        const data = await response.json();
        return data;

    } catch (error) {
        console.error('Error updating edge:', error);
        throw error;
    }
}

// Example usage
const edgeId = 1; // Replace with actual edge ID
const updateData = {
    from_node_id: 1,
    to_node_id: 2,
    type: 'connection',
    condition: 'updated condition',
    is_locked: true // Optional: Lock for current user, or false to unlock
};

updateEdge(edgeId, updateData)
    .then(result => {
        console.log('Edge updated successfully:', result.data.edge);
    })
    .catch(error => {
        console.error('Failed to update edge:', error);
    });

# TellsTree SDK - Edges API (Python)
# Update an existing edge

import requests

API_BASE_URL = 'https://tellstree.com/api'
API_TOKEN = 'your_jwt_token_here'

def update_edge(edge_id, update_data):
    """
    Update an existing edge
    
    Args:
        edge_id (int): The ID of the edge to update
        update_data (dict): The update data
            - from_node_id (int): ID of the source node
            - to_node_id (int): ID of the target node
            - type (str, optional): Edge type
            - condition (str, optional): Edge activation condition
    
    Returns:
        dict: API response with updated edge data
    """
    try:
        headers = {
            'Accept': 'application/json',
            'Content-Type': 'application/json',
            'Authorization': f'Bearer {API_TOKEN}'
        }
        
        response = requests.put(
            f'{API_BASE_URL}/edges/{edge_id}',
            headers=headers,
            json=update_data,
            timeout=30
        )
        
        response.raise_for_status()
        return response.json()
        
    except requests.exceptions.RequestException as e:
        print(f'Error updating edge: {e}')
        raise e

# Example usage
if __name__ == '__main__':
    edge_id = 1  # Replace with actual edge ID
    update_data = {
        'from_node_id': 1,
        'to_node_id': 2,
        'type': 'connection',
        'condition': 'updated condition'
    }
    
    try:
        result = update_edge(edge_id, update_data)
        print('Edge updated successfully:', result['data']['edge'])
    except Exception as error:
        print('Failed to update edge:', error)

<?php
/**
 * TellsTree SDK - Edges API (PHP)
 * Update an existing edge
 */

const API_BASE_URL = 'https://tellstree.com/api';
const API_TOKEN = 'your_jwt_token_here';

/**
 * Update an existing edge
 * 
 * @param int $edgeId The ID of the edge to update
 * @param array $updateData The update data
 *                          - from_node_id (int): ID of the source node
 *                          - to_node_id (int): ID of the target node
 *                          - type (string, optional): Edge type
 *                          - condition (string, optional): Edge activation condition
 *                          - is_locked (bool, optional): Lock state (true to lock, false to unlock)
 * @return array API response with updated edge data
 * @throws Exception If the request fails
 */
function updateEdge($edgeId, $updateData) {
    $url = API_BASE_URL . '/edges/' . $edgeId;
    
    $headers = [
        'Accept: application/json',
        'Content-Type: application/json',
        'Authorization: Bearer ' . API_TOKEN
    ];
    
    $context = stream_context_create([
        'http' => [
            'method' => 'PUT',
            'header' => implode("\r\n", $headers),
            'content' => json_encode($updateData)
        ]
    ]);
    
    $response = file_get_contents($url, false, $context);
    
    if ($response === false) {
        throw new Exception('Failed to update edge: Unable to connect to API');
    }
    
    $data = json_decode($response, true);
    
    if (json_last_error() !== JSON_ERROR_NONE) {
        throw new Exception('Failed to decode JSON response: ' . json_last_error_msg());
    }
    
    return $data;
}

// Example usage
try {
    $edgeId = 1; // Replace with actual edge ID
    $updateData = [
        'from_node_id' => 1,
        'to_node_id' => 2,
        'type' => 'connection',
        'condition' => 'updated condition',
        'is_locked' => true // Optional: Lock for current user, or false to unlock
    ];
    
    $result = updateEdge($edgeId, $updateData);
    echo "Edge updated successfully:\n";
    print_r($result['data']['edge']);
    
} catch (Exception $error) {
    echo "Failed to update edge: " . $error->getMessage() . "\n";
}
?>

#!/bin/bash

# TellsTree SDK - Edges API (cURL)
# Update an existing edge

API_BASE_URL="https://tellstree.com/api"
API_TOKEN="your_jwt_token_here"
EDGE_ID="1" # Replace with actual edge ID

# Update an existing edge
curl -X PUT "${API_BASE_URL}/edges/${EDGE_ID}" \
  -H "Accept: application/json" \
  -H "Content-Type: application/json" \
  -H "Authorization: Bearer ${API_TOKEN}" \
  -d '{
    "from_node_id": 1,
    "to_node_id": 2,
    "type": "connection",
    "condition": "updated condition"
  }'

{
    "method": "DELETE",
    "url": "http://localhost:8000/api/edges/107",
    "headers": {
        "Authorization": [
            "***REDACTED***"
        ],
        "Accept": "application/json",
        "Content-Type": "application/json"
    },
    "payload": null,
    "recorded_at": "2025-10-17T22:41:32+00:00"
}

// TellsTree SDK - Edges API (JavaScript)
// Delete an edge

const API_BASE_URL = 'https://tellstree.com/api';
const API_TOKEN = 'your_jwt_token_here';

/**
 * Delete an edge permanently
 * @param {number} edgeId - The ID of the edge to delete
 * @returns {Promise<boolean>} True if deletion was successful
 */
async function deleteEdge(edgeId) {
    try {
        const response = await fetch(`${API_BASE_URL}/edges/${edgeId}`, {
            method: 'DELETE',
            headers: {
                'Accept': 'application/json',
                'Authorization': `Bearer ${API_TOKEN}`
            }
        });

        if (response.status === 204) {
            return true; // Successfully deleted (No Content)
        } else if (!response.ok) {
            throw new Error(`HTTP ${response.status}: ${response.statusText}`);
        }

        return true;

    } catch (error) {
        console.error('Error deleting edge:', error);
        throw error;
    }
}

// Example usage
const edgeId = 1; // Replace with actual edge ID

deleteEdge(edgeId)
    .then(success => {
        if (success) {
            console.log('Edge deleted successfully');
        }
    })
    .catch(error => {
        console.error('Failed to delete edge:', error);
    });

# TellsTree SDK - Edges API (Python)
# Delete an edge

import requests

API_BASE_URL = 'https://tellstree.com/api'
API_TOKEN = 'your_jwt_token_here'

def delete_edge(edge_id):
    """
    Delete an edge permanently
    
    Args:
        edge_id (int): The ID of the edge to delete
    
    Returns:
        bool: True if deletion was successful
    """
    try:
        headers = {
            'Accept': 'application/json',
            'Authorization': f'Bearer {API_TOKEN}'
        }
        
        response = requests.delete(
            f'{API_BASE_URL}/edges/{edge_id}',
            headers=headers,
            timeout=30
        )
        
        if response.status_code == 204:
            return True  # Successfully deleted (No Content)
        else:
            response.raise_for_status()
            return True
        
    except requests.exceptions.RequestException as e:
        print(f'Error deleting edge: {e}')
        raise e

# Example usage
if __name__ == '__main__':
    edge_id = 1  # Replace with actual edge ID
    
    try:
        success = delete_edge(edge_id)
        if success:
            print('Edge deleted successfully')
    except Exception as error:
        print('Failed to delete edge:', error)

<?php
/**
 * TellsTree SDK - Edges API (PHP)
 * Delete an edge
 */

const API_BASE_URL = 'https://tellstree.com/api';
const API_TOKEN = 'your_jwt_token_here';

/**
 * Delete an edge permanently
 * 
 * @param int $edgeId The ID of the edge to delete
 * @return bool True if deletion was successful
 * @throws Exception If the request fails
 */
function deleteEdge($edgeId) {
    $url = API_BASE_URL . '/edges/' . $edgeId;
    
    $headers = [
        'Accept: application/json',
        'Authorization: Bearer ' . API_TOKEN
    ];
    
    $context = stream_context_create([
        'http' => [
            'method' => 'DELETE',
            'header' => implode("\r\n", $headers)
        ]
    ]);
    
    $response = file_get_contents($url, false, $context);
    
    // Check if the request was successful
    // For DELETE requests, a 204 No Content response is expected
    $responseHeaders = $http_response_header ?? [];
    
    foreach ($responseHeaders as $header) {
        if (strpos($header, 'HTTP/') === 0) {
            if (strpos($header, '204') !== false) {
                return true; // Successfully deleted
            }
        }
    }
    
    if ($response === false) {
        throw new Exception('Failed to delete edge: Unable to connect to API');
    }
    
    return true;
}

// Example usage
try {
    $edgeId = 1; // Replace with actual edge ID
    
    $success = deleteEdge($edgeId);
    if ($success) {
        echo "Edge deleted successfully\n";
    }
    
} catch (Exception $error) {
    echo "Failed to delete edge: " . $error->getMessage() . "\n";
}
?>

#!/bin/bash

# TellsTree SDK - Edges API (cURL)
# Delete an edge

API_BASE_URL="https://tellstree.com/api"
API_TOKEN="your_jwt_token_here"
EDGE_ID="1" # Replace with actual edge ID

# Delete an edge permanently
curl -X DELETE "${API_BASE_URL}/edges/${EDGE_ID}" \
  -H "Accept: application/json" \
  -H "Authorization: Bearer ${API_TOKEN}"

curl -X GET "https://tellstree.com/api/media?project_id=42&type=image" \
  -H "Authorization: Bearer your_jwt_token" \
  -H "Accept: application/json" \
  -H "Content-Type: application/json"

const response = await fetch('https://tellstree.com/api/media?project_id=42', {
    method: 'GET',
    headers: {
        'Authorization': 'Bearer your_jwt_token',
        'Accept': 'application/json',
        'Content-Type': 'application/json'
    }
});

const data = await response.json();
console.log(data.data.media);

$response = Http::withHeaders([
    'Authorization' => 'Bearer ' . $token,
    'Accept' => 'application/json',
])->get('https://tellstree.com/api/media', [
    'project_id' => 42,
    'type' => 'image'
]);

$media = $response->json()['data']['media'];

import requests

headers = {
    'Authorization': 'Bearer your_jwt_token',
    'Accept': 'application/json',
    'Content-Type': 'application/json'
}

params = {
    'project_id': 42,
    'type': 'image'
}

response = requests.get(
    'https://tellstree.com/api/media',
    headers=headers,
    params=params
)

media = response.json()['data']['media']

GET /api/media?project_id=42&type=image HTTP/1.1
Host: tellstree.com
Authorization: Bearer your_jwt_token
Accept: application/json
Content-Type: application/json

curl -X POST "https://tellstree.com/api/media" \
  -H "Authorization: Bearer your_jwt_token" \
  -H "Accept: application/json" \
  -F "file=@/path/to/image.jpg" \
  -F "project_id=42" \
  -F "alt_text=Uploaded image" \
  -F "description=User uploaded media"

const formData = new FormData();
formData.append('file', fileInput.files[0]);
formData.append('project_id', '42');
formData.append('alt_text', 'Uploaded image');
formData.append('description', 'User uploaded media');

const response = await fetch('https://tellstree.com/api/media', {
    method: 'POST',
    headers: {
        'Authorization': 'Bearer your_jwt_token',
        'Accept': 'application/json'
    },
    body: formData
});

const data = await response.json();
console.log(data.data);

$response = Http::withHeaders([
    'Authorization' => 'Bearer ' . $token,
    'Accept' => 'application/json',
])->attach(
    'file', file_get_contents($filePath), $fileName
)->post('https://tellstree.com/api/media', [
    'project_id' => 42,
    'alt_text' => 'Uploaded image',
    'description' => 'User uploaded media'
]);

$media = $response->json()['data'];

import requests

headers = {
    'Authorization': 'Bearer your_jwt_token',
    'Accept': 'application/json'
}

files = {
    'file': open('image.jpg', 'rb')
}

data = {
    'project_id': 42,
    'alt_text': 'Uploaded image',
    'description': 'User uploaded media'
}

response = requests.post(
    'https://tellstree.com/api/media',
    headers=headers,
    files=files,
    data=data
)

media = response.json()['data']

POST /api/media HTTP/1.1
Host: tellstree.com
Authorization: Bearer your_jwt_token
Accept: application/json
Content-Type: multipart/form-data; boundary=----boundary

------boundary
Content-Disposition: form-data; name="file"; filename="image.jpg"
Content-Type: image/jpeg

[binary file data]
------boundary
Content-Disposition: form-data; name="project_id"

42
------boundary--

{
    "method": "GET",
    "url": "http://localhost:8000/api/comments?project_id=90",
    "headers": {
        "Authorization": [
            "***REDACTED***"
        ],
        "Accept": "application/json",
        "Content-Type": "application/json"
    },
    "payload": null,
    "recorded_at": "2025-10-17T22:41:31+00:00"
}

/**
 * TellsTree Comments API - List Comments
 * 
 * This example demonstrates how to fetch comments for a project using JavaScript.
 * Replace 'your_jwt_token' with your actual authentication token.
 */

const response = await fetch('https://tellstree.com/api/comments?project_id=42', {
    method: 'GET',
    headers: {
        'Authorization': 'Bearer your_jwt_token',
        'Accept': 'application/json',
        'Content-Type': 'application/json'
    }
});

const data = await response.json();
console.log(data.data.comments);

<?php
/**
 * TellsTree Comments API - List Comments
 * 
 * This example demonstrates how to fetch comments for a project using PHP.
 * Replace 'your_jwt_token' with your actual authentication token.
 */

use Illuminate\Support\Facades\Http;

$token = 'your_jwt_token';

$response = Http::withHeaders([
    'Authorization' => 'Bearer ' . $token,
    'Accept' => 'application/json',
])->get('https://tellstree.com/api/comments', [
    'project_id' => 42,
    'status' => 'open'
]);

$comments = $response->json()['data']['comments'];
var_dump($comments);

"""
TellsTree Comments API - List Comments

This example demonstrates how to fetch comments for a project using Python.
Replace 'your_jwt_token' with your actual authentication token.

Requirements:
pip install requests
"""

import requests

headers = {
    'Authorization': 'Bearer your_jwt_token',
    'Accept': 'application/json',
    'Content-Type': 'application/json'
}

params = {
    'project_id': 42,
    'status': 'open'
}

response = requests.get(
    'https://tellstree.com/api/comments',
    headers=headers,
    params=params
)

comments = response.json()['data']['comments']
print(comments)

# TellsTree Comments API - List Comments
# 
# This example demonstrates how to fetch comments for a project using cURL.
# Replace 'your_jwt_token' with your actual authentication token.

curl -X GET "https://tellstree.com/api/comments?project_id=42&status=open" \
  -H "Authorization: Bearer your_jwt_token" \
  -H "Accept: application/json" \
  -H "Content-Type: application/json"

{
    "method": "POST",
    "url": "http://localhost:8000/api/comments",
    "headers": {
        "Authorization": [
            "***REDACTED***"
        ],
        "Accept": "application/json",
        "Content-Type": "application/json"
    },
    "payload": {
        "content": "API Test Comment content with enough length",
        "rating": 4,
        "project_id": 90
    },
    "recorded_at": "2025-10-17T22:41:31+00:00"
}

/**
 * TellsTree Comments API - Create Comment
 * 
 * This example demonstrates how to create a new comment using JavaScript.
 * Replace 'your_jwt_token' with your actual authentication token.
 */

const response = await fetch('https://tellstree.com/api/comments', {
    method: 'POST',
    headers: {
        'Authorization': 'Bearer your_jwt_token',
        'Accept': 'application/json',
        'Content-Type': 'application/json'
    },
    body: JSON.stringify({
        content: 'API Test Comment content with enough length',
        rating: 4,
        project_id: 40
    })
});

const data = await response.json();
console.log(data.data);

<?php
/**
 * TellsTree Comments API - Create Comment
 * 
 * This example demonstrates how to create a new comment using PHP.
 * Replace 'your_jwt_token' with your actual authentication token.
 */

use Illuminate\Support\Facades\Http;

$token = 'your_jwt_token';

$response = Http::withHeaders([
    'Authorization' => 'Bearer ' . $token,
    'Accept' => 'application/json',
])->post('https://tellstree.com/api/comments', [
    'content' => 'API Test Comment content with enough length',
    'rating' => 4,
    'project_id' => 40
]);

$comment = $response->json()['data'];
var_dump($comment);

"""
TellsTree Comments API - Create Comment

This example demonstrates how to create a new comment using Python.
Replace 'your_jwt_token' with your actual authentication token.

Requirements:
pip install requests
"""

import requests

headers = {
    'Authorization': 'Bearer your_jwt_token',
    'Accept': 'application/json',
    'Content-Type': 'application/json'
}

data = {
    'content': 'API Test Comment content with enough length',
    'rating': 4,
    'project_id': 40
}

response = requests.post(
    'https://tellstree.com/api/comments',
    headers=headers,
    json=data
)

comment = response.json()['data']
print(comment)

# TellsTree Comments API - Create Comment
# 
# This example demonstrates how to create a new comment using cURL.
# Replace 'your_jwt_token' with your actual authentication token.

curl -X POST "https://tellstree.com/api/comments" \
  -H "Authorization: Bearer your_jwt_token" \
  -H "Accept: application/json" \
  -H "Content-Type: application/json" \
  -d '{
    "content": "API Test Comment content with enough length",
    "rating": 4,
    "project_id": 40
  }'

{
    "method": "GET",
    "url": "https://tellstree.com/api/themes",
    "headers": {
        "Accept": "application/json"
    },
    "query_parameters": {
        "page": "1",
        "per_page": "15"
    }
}

// TellsTree API - List All Themes
// This example demonstrates how to fetch all available themes from the TellsTree API

const API_BASE_URL = 'https://tellstree.com/api';

/**
 * Fetch all themes from TellsTree API
 * @param {Object} options - Configuration options
 * @param {number} options.page - Page number (default: 1)
 * @param {number} options.per_page - Items per page (default: 15)
 * @returns {Promise<Object>} Themes data
 */
async function listAllThemes(options = {}) {
    const { page = 1, per_page = 15 } = options;
    
    // Build query parameters
    const params = new URLSearchParams({
        page: page.toString(),
        per_page: per_page.toString()
    });
    
    const url = `${API_BASE_URL}/themes?${params}`;
    
    try {
        const response = await fetch(url, {
            method: 'GET',
            headers: {
                'Accept': 'application/json',
                'Content-Type': 'application/json'
            }
        });
        
        if (!response.ok) {
            throw new Error(`HTTP error! status: ${response.status}`);
        }
        
        const data = await response.json();
        return data;
        
    } catch (error) {
        console.error('Error fetching themes:', error);
        throw error;
    }
}

/**
 * Example usage
 */
async function example() {
    try {
        console.log('Fetching themes...');
        
        // Get first page of themes
        const themes = await listAllThemes();
        console.log('Themes received:', themes);
        
        // Get specific page with custom page size
        const customPageThemes = await listAllThemes({ page: 1, per_page: 10 });
        console.log('Custom page themes:', customPageThemes);
        
    } catch (error) {
        console.error('Example failed:', error);
    }
}

// Export for module usage
if (typeof module !== 'undefined' && module.exports) {
    module.exports = { listAllThemes };
}

// Run example if called directly
if (require.main === module) {
    example();
}

#!/usr/bin/env python3
"""
TellsTree API - List All Themes
This example demonstrates how to fetch all available themes from the TellsTree API
"""

import requests
import json
from typing import Optional, Dict, Any

API_BASE_URL = 'https://tellstree.com/api'

def list_all_themes(page: int = 1, per_page: int = 15) -> Dict[str, Any]:
    """
    Fetch all themes from TellsTree API
    
    Args:
        page (int): Page number (default: 1)
        per_page (int): Items per page (default: 15)
        
    Returns:
        Dict[str, Any]: Themes data
        
    Raises:
        requests.RequestException: If the API request fails
    """
    url = f"{API_BASE_URL}/themes"
    
    params = {
        'page': page,
        'per_page': per_page
    }
    
    headers = {
        'Accept': 'application/json',
        'Content-Type': 'application/json'
    }
    
    try:
        response = requests.get(url, params=params, headers=headers)
        response.raise_for_status()
        
        return response.json()
        
    except requests.RequestException as e:
        print(f"Error fetching themes: {e}")
        raise

def main():
    """Example usage"""
    try:
        print("Fetching themes...")
        
        # Get first page of themes
        themes = list_all_themes()
        print(f"Themes received: {json.dumps(themes, indent=2)}")
        
        # Get specific page with custom page size
        custom_page_themes = list_all_themes(page=1, per_page=10)
        print(f"Custom page themes: {json.dumps(custom_page_themes, indent=2)}")
        
    except Exception as e:
        print(f"Example failed: {e}")

if __name__ == '__main__':
    main()

<?php
/**
 * TellsTree API - List All Themes
 * This example demonstrates how to fetch all available themes from the TellsTree API
 */

const API_BASE_URL = 'https://tellstree.com/api';

/**
 * Fetch all themes from TellsTree API
 * 
 * @param int $page Page number (default: 1)
 * @param int $per_page Items per page (default: 15)
 * @return array Themes data
 * @throws Exception If the API request fails
 */
function listAllThemes($page = 1, $per_page = 15) {
    $url = API_BASE_URL . '/themes';
    
    // Build query parameters
    $queryParams = http_build_query([
        'page' => $page,
        'per_page' => $per_page
    ]);
    
    $fullUrl = $url . '?' . $queryParams;
    
    // Setup request headers
    $headers = [
        'Accept: application/json',
        'Content-Type: application/json'
    ];
    
    // Create context for the request
    $context = stream_context_create([
        'http' => [
            'method' => 'GET',
            'header' => implode("\r\n", $headers),
            'timeout' => 30
        ]
    ]);
    
    // Make the request
    $response = @file_get_contents($fullUrl, false, $context);
    
    if ($response === false) {
        $error = error_get_last();
        throw new Exception("Error fetching themes: " . ($error['message'] ?? 'Unknown error'));
    }
    
    // Parse the response
    $data = json_decode($response, true);
    
    if (json_last_error() !== JSON_ERROR_NONE) {
        throw new Exception("Error parsing JSON response: " . json_last_error_msg());
    }
    
    return $data;
}

/**
 * Example usage
 */
function example() {
    try {
        echo "Fetching themes...\n";
        
        // Get first page of themes
        $themes = listAllThemes();
        echo "Themes received:\n" . json_encode($themes, JSON_PRETTY_PRINT) . "\n";
        
        // Get specific page with custom page size
        $customPageThemes = listAllThemes(1, 10);
        echo "Custom page themes:\n" . json_encode($customPageThemes, JSON_PRETTY_PRINT) . "\n";
        
    } catch (Exception $e) {
        echo "Example failed: " . $e->getMessage() . "\n";
    }
}

// Run example if called directly
if (basename(__FILE__) === basename($_SERVER['SCRIPT_NAME'] ?? '')) {
    example();
}
?>

curl -X GET "https://tellstree.com/api/themes?page=1&per_page=10" \
     -H "Authorization: Bearer your-jwt-token" \
     -H "Accept: application/json"

{
    "method": "GET",
    "url": "https://tellstree.com/api/themes/{theme}",
    "headers": {
        "Accept": "application/json"
    },
    "url_parameters": {
        "theme": "dialog"
    }
}

// TellsTree API - Get Specific Theme
// This example demonstrates how to fetch a specific theme by domain

const API_BASE_URL = 'https://tellstree.com/api';

/**
 * Fetch a specific theme by domain
 * @param {string} themeDomain - The domain identifier of the theme (e.g., 'dialog')
 * @returns {Promise<Object>} Theme data
 */
async function getTheme(themeDomain) {
    if (!themeDomain) {
        throw new Error('Theme domain is required');
    }
    
    const url = `${API_BASE_URL}/themes/${encodeURIComponent(themeDomain)}`;
    
    try {
        const response = await fetch(url, {
            method: 'GET',
            headers: {
                'Accept': 'application/json',
                'Content-Type': 'application/json'
            }
        });
        
        if (!response.ok) {
            if (response.status === 404) {
                throw new Error(`Theme '${themeDomain}' not found`);
            }
            throw new Error(`HTTP error! status: ${response.status}`);
        }
        
        const data = await response.json();
        return data;
        
    } catch (error) {
        console.error(`Error fetching theme '${themeDomain}':`, error);
        throw error;
    }
}

/**
 * Example usage
 */
async function example() {
    try {
        console.log('Fetching dialog theme...');
        
        // Get the dialog theme
        const dialogTheme = await getTheme('dialog');
        console.log('Dialog theme received:', dialogTheme);
        
        // Extract useful information
        console.log('Theme details:');
        console.log(`- Name: ${dialogTheme.data.theme.name}`);
        console.log(`- Domain: ${dialogTheme.data.theme.domain}`);
        console.log(`- Projects using this theme: ${dialogTheme.data.theme.statistics.projects_count}`);
        console.log(`- Available node types: ${dialogTheme.data.theme.node_types.join(', ')}`);
        
    } catch (error) {
        console.error('Example failed:', error);
    }
}

// Export for module usage
if (typeof module !== 'undefined' && module.exports) {
    module.exports = { getTheme };
}

// Run example if called directly
if (require.main === module) {
    example();
}

#!/usr/bin/env python3
"""
TellsTree API - Get Specific Theme
This example demonstrates how to fetch a specific theme by domain
"""

import requests
import json
from typing import Dict, Any

API_BASE_URL = 'https://tellstree.com/api'

def get_theme(theme_domain: str) -> Dict[str, Any]:
    """
    Fetch a specific theme by domain
    
    Args:
        theme_domain (str): The domain identifier of the theme (e.g., 'dialog')
        
    Returns:
        Dict[str, Any]: Theme data
        
    Raises:
        ValueError: If theme_domain is empty
        requests.RequestException: If the API request fails
    """
    if not theme_domain:
        raise ValueError('Theme domain is required')
    
    url = f"{API_BASE_URL}/themes/{theme_domain}"
    
    headers = {
        'Accept': 'application/json',
        'Content-Type': 'application/json'
    }
    
    try:
        response = requests.get(url, headers=headers)
        
        if response.status_code == 404:
            raise requests.RequestException(f"Theme '{theme_domain}' not found")
        
        response.raise_for_status()
        return response.json()
        
    except requests.RequestException as e:
        print(f"Error fetching theme '{theme_domain}': {e}")
        raise

def main():
    """Example usage"""
    try:
        print("Fetching dialog theme...")
        
        # Get the dialog theme
        dialog_theme = get_theme('dialog')
        print(f"Dialog theme received: {json.dumps(dialog_theme, indent=2)}")
        
        # Extract useful information
        theme_data = dialog_theme['data']['theme']
        print("\nTheme details:")
        print(f"- Name: {theme_data['name']}")
        print(f"- Domain: {theme_data['domain']}")
        print(f"- Projects using this theme: {theme_data['statistics']['projects_count']}")
        print(f"- Available node types: {', '.join(theme_data['node_types'])}")
        
    except Exception as e:
        print(f"Example failed: {e}")

if __name__ == '__main__':
    main()

<?php
/**
 * TellsTree API - Get Specific Theme
 * This example demonstrates how to fetch a specific theme by domain
 */

const API_BASE_URL = 'https://tellstree.com/api';

/**
 * Fetch a specific theme by domain
 * 
 * @param string $themeDomain The domain identifier of the theme (e.g., 'dialog')
 * @return array Theme data
 * @throws Exception If the API request fails or theme domain is empty
 */
function getTheme($themeDomain) {
    if (empty($themeDomain)) {
        throw new Exception('Theme domain is required');
    }
    
    $url = API_BASE_URL . '/themes/' . urlencode($themeDomain);
    
    // Setup request headers
    $headers = [
        'Accept: application/json',
        'Content-Type: application/json'
    ];
    
    // Create context for the request
    $context = stream_context_create([
        'http' => [
            'method' => 'GET',
            'header' => implode("\r\n", $headers),
            'timeout' => 30
        ]
    ]);
    
    // Make the request
    $response = @file_get_contents($url, false, $context);
    
    if ($response === false) {
        // Check if it's a 404 error
        if (isset($http_response_header)) {
            foreach ($http_response_header as $header) {
                if (strpos($header, '404') !== false) {
                    throw new Exception("Theme '$themeDomain' not found");
                }
            }
        }
        
        $error = error_get_last();
        throw new Exception("Error fetching theme '$themeDomain': " . ($error['message'] ?? 'Unknown error'));
    }
    
    // Parse the response
    $data = json_decode($response, true);
    
    if (json_last_error() !== JSON_ERROR_NONE) {
        throw new Exception("Error parsing JSON response: " . json_last_error_msg());
    }
    
    return $data;
}

/**
 * Example usage
 */
function example() {
    try {
        echo "Fetching dialog theme...\n";
        
        // Get the dialog theme
        $dialogTheme = getTheme('dialog');
        echo "Dialog theme received:\n" . json_encode($dialogTheme, JSON_PRETTY_PRINT) . "\n";
        
        // Extract useful information
        $themeData = $dialogTheme['data']['theme'];
        echo "\nTheme details:\n";
        echo "- Name: " . $themeData['name'] . "\n";
        echo "- Domain: " . $themeData['domain'] . "\n";
        echo "- Projects using this theme: " . $themeData['statistics']['projects_count'] . "\n";
        echo "- Available node types: " . implode(', ', $themeData['node_types']) . "\n";
        
    } catch (Exception $e) {
        echo "Example failed: " . $e->getMessage() . "\n";
    }
}

// Run example if called directly
if (basename(__FILE__) === basename($_SERVER['SCRIPT_NAME'] ?? '')) {
    example();
}
?>

curl -X GET "https://tellstree.com/api/themes/dialog" \
     -H "Authorization: Bearer your-jwt-token" \
     -H "Accept: application/json"

{
    "method": "GET",
    "url": "/api/designs",
    "headers": [],
    "payload": null,
    "recorded_at": "2025-10-17T22:41:31+00:00"
}

// TellsTree SDK - Designs API (JavaScript)
// List all designs (public endpoint)

const API_BASE_URL = 'https://tellstree.com/api';

/**
 * Get all available designs (public endpoint - no authentication required)
 * @returns {Promise<Object>} API response with designs data
 */
async function listAllDesigns() {
    try {
        const response = await fetch(`${API_BASE_URL}/designs`, {
            method: 'GET',
            headers: {
                'Accept': 'application/json'
            }
        });

        if (!response.ok) {
            throw new Error(`HTTP ${response.status}: ${response.statusText}`);
        }

        const data = await response.json();
        return data;
    } catch (error) {
        console.error('Error fetching designs:', error);
        throw error;
    }
}

// Example usage (only runs when executed directly)
if (typeof require !== 'undefined' && require.main === module) {
    // Example: Get all designs
    listAllDesigns()
        .then(result => {
            console.log('All Designs:');
            console.log(JSON.stringify(result, null, 2));
        })
        .catch(error => {
            console.error('Failed to fetch designs:', error.message);
        });
}

// Export for use in other modules
if (typeof module !== 'undefined' && module.exports) {
    module.exports = { listAllDesigns };
}

"""
TellsTree SDK - Designs API (Python)
List all designs (public endpoint)
"""

import requests
import json
from typing import Dict, Any

API_BASE_URL = "https://tellstree.com/api"

def list_all_designs() -> Dict[str, Any]:
    """
    Get all available designs (public endpoint - no authentication required)
    
    Returns:
        Dict[str, Any]: API response with designs data
        
    Raises:
        requests.RequestException: If the API request fails
        ValueError: If the response cannot be parsed as JSON
    """
    try:
        headers = {
            'Accept': 'application/json'
        }
        
        response = requests.get(f"{API_BASE_URL}/designs", headers=headers)
        response.raise_for_status()
        
        return response.json()
        
    except requests.RequestException as e:
        print(f"Error fetching designs: {e}")
        raise
    except json.JSONDecodeError as e:
        print(f"Error parsing JSON response: {e}")
        raise ValueError("Invalid JSON response from API")

def main():
    """Example usage of the designs API"""
    try:
        # Get all designs
        result = list_all_designs()
        print("All Designs:")
        print(json.dumps(result, indent=2))
        
    except Exception as e:
        print(f"Failed to fetch designs: {e}")

if __name__ == "__main__":
    main()

<?php
/**
 * TellsTree SDK - Designs API (PHP)
 * List all designs (public endpoint)
 */

const API_BASE_URL = 'https://tellstree.com/api';

/**
 * Get all available designs (public endpoint - no authentication required)
 * 
 * @return array API response with designs data
 * @throws Exception If the API request fails
 */
function listAllDesigns() {
    $url = API_BASE_URL . "/designs";
    
    $context = stream_context_create([
        'http' => [
            'method' => 'GET',
            'header' => [
                'Accept: application/json'
            ],
            'ignore_errors' => true
        ]
    ]);
    
    $response = file_get_contents($url, false, $context);
    
    if ($response === false) {
        throw new Exception('Failed to make API request');
    }
    
    // Get HTTP status code
    $statusLine = $http_response_header[0] ?? '';
    preg_match('/\d{3}/', $statusLine, $matches);
    $statusCode = $matches[0] ?? 0;
    
    if ($statusCode >= 400) {
        $errorData = json_decode($response, true);
        $message = $errorData['message'] ?? 'HTTP Error ' . $statusCode;
        throw new Exception($message, (int)$statusCode);
    }
    
    $data = json_decode($response, true);
    
    if (json_last_error() !== JSON_ERROR_NONE) {
        throw new Exception('Invalid JSON response: ' . json_last_error_msg());
    }
    
    return $data;
}

// Example usage (only runs when executed directly)
if (basename(__FILE__) === basename($_SERVER['SCRIPT_FILENAME'])) {
    try {
        // Get all designs
        $result = listAllDesigns();
        echo "All Designs:\n";
        echo json_encode($result, JSON_PRETTY_PRINT) . "\n";
        
    } catch (Exception $e) {
        echo "Failed to fetch designs: " . $e->getMessage() . "\n";
        exit(1);
    }
}
?>

curl -H "Accept: application/json" \
     "https://tellstree.com/api/designs"

{
    "method": "GET",
    "url": "/api/designs/original",
    "headers": [],
    "payload": null,
    "recorded_at": "2025-10-17T22:41:31+00:00"
}

// TellsTree SDK - Designs API (JavaScript)
// Get specific design by domain (public endpoint)

const API_BASE_URL = 'https://tellstree.com/api';

/**
 * Get a specific design by domain (public endpoint - no authentication required)
 * @param {string} designDomain - The domain identifier of the design (e.g., 'original', 'modern')
 * @returns {Promise<Object>} API response with design data
 */
async function getDesign(designDomain) {
    try {
        const response = await fetch(`${API_BASE_URL}/designs/${designDomain}`, {
            method: 'GET',
            headers: {
                'Accept': 'application/json'
            }
        });

        if (!response.ok) {
            throw new Error(`HTTP ${response.status}: ${response.statusText}`);
        }

        const data = await response.json();
        return data;
    } catch (error) {
        console.error('Error fetching design:', error);
        throw error;
    }
}

// Example usage (only runs when executed directly)
if (typeof require !== 'undefined' && require.main === module) {
    // Example: Get the 'original' design
    getDesign('original')
        .then(result => {
            console.log('Original Design:');
            console.log(JSON.stringify(result, null, 2));
        })
        .catch(error => {
            console.error('Failed to fetch design:', error.message);
        });
}

// Export for use in other modules
if (typeof module !== 'undefined' && module.exports) {
    module.exports = { getDesign };
}

"""
TellsTree SDK - Designs API (Python)
Get specific design by domain (public endpoint)
"""

import requests
import json
from typing import Dict, Any

API_BASE_URL = "https://tellstree.com/api"

def get_design(design_domain: str) -> Dict[str, Any]:
    """
    Get a specific design by domain (public endpoint - no authentication required)
    
    Args:
        design_domain (str): The domain identifier of the design (e.g., 'original', 'modern')
        
    Returns:
        Dict[str, Any]: API response with design data
        
    Raises:
        requests.RequestException: If the API request fails
        ValueError: If the response cannot be parsed as JSON
    """
    try:
        headers = {
            'Accept': 'application/json'
        }
        
        response = requests.get(f"{API_BASE_URL}/designs/{design_domain}", headers=headers)
        response.raise_for_status()
        
        return response.json()
        
    except requests.RequestException as e:
        print(f"Error fetching design: {e}")
        raise
    except json.JSONDecodeError as e:
        print(f"Error parsing JSON response: {e}")
        raise ValueError("Invalid JSON response from API")

def main():
    """Example usage of the designs API"""
    try:
        # Get the 'original' design
        result = get_design('original')
        print("Original Design:")
        print(json.dumps(result, indent=2))
        
    except Exception as e:
        print(f"Failed to fetch design: {e}")

if __name__ == "__main__":
    main()

<?php
/**
 * TellsTree SDK - Designs API (PHP)
 * Get specific design by domain (public endpoint)
 */

const API_BASE_URL = 'https://tellstree.com/api';

/**
 * Get a specific design by domain (public endpoint - no authentication required)
 * 
 * @param string $designDomain The domain identifier of the design (e.g., 'original', 'modern')
 * @return array API response with design data
 * @throws Exception If the API request fails
 */
function getDesign($designDomain) {
    $url = API_BASE_URL . "/designs/{$designDomain}";
    
    $context = stream_context_create([
        'http' => [
            'method' => 'GET',
            'header' => [
                'Accept: application/json'
            ],
            'ignore_errors' => true
        ]
    ]);
    
    $response = file_get_contents($url, false, $context);
    
    if ($response === false) {
        throw new Exception('Failed to make API request');
    }
    
    // Get HTTP status code
    $statusLine = $http_response_header[0] ?? '';
    preg_match('/\d{3}/', $statusLine, $matches);
    $statusCode = $matches[0] ?? 0;
    
    if ($statusCode >= 400) {
        $errorData = json_decode($response, true);
        $message = $errorData['message'] ?? 'HTTP Error ' . $statusCode;
        throw new Exception($message, (int)$statusCode);
    }
    
    $data = json_decode($response, true);
    
    if (json_last_error() !== JSON_ERROR_NONE) {
        throw new Exception('Invalid JSON response: ' . json_last_error_msg());
    }
    
    return $data;
}

// Example usage (only runs when executed directly)
if (basename(__FILE__) === basename($_SERVER['SCRIPT_FILENAME'])) {
    try {
        // Get the 'original' design
        $result = getDesign('original');
        echo "Original Design:\n";
        echo json_encode($result, JSON_PRETTY_PRINT) . "\n";
        
    } catch (Exception $e) {
        echo "Failed to fetch design: " . $e->getMessage() . "\n";
        exit(1);
    }
}
?>

curl -H "Accept: application/json" \
     "https://tellstree.com/api/designs/original"