SPMC API Documentation

async function apiV1Builder-orders(group_id, writer_id, page, page_size) {
  try {
    const response = await fetch('https://api.spmc.dev/api/v1/builder-orders/', {
    method: 'GET',
    headers: {
      '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 calling /api/v1/builder-orders/:', error);
    throw error;
  }
}

import requests
from typing import Dict, Any, Optional

def apiV1Builder-orders(group_id, writer_id, page, page_size) -> Dict[str, Any]:
    """
    List Builder Orders
    
    Args:
        group_id: Filter by group ID
        writer_id: Filter by writer ID
        page: Page number
        page_size: Items per page
    
    Returns:
        API response as dictionary
    
    Raises:
        requests.exceptions.RequestException: If the request fails
    """
    try:
        url = 'https://api.spmc.dev/api/v1/builder-orders/'
        headers = {
            "Content-Type": "application/json"
    }
        params = {
            'group_id': group_id,
            'writer_id': writer_id,
            'page': page,
            'page_size': page_size,
        }
        response = requests.get(url, params=params, headers=headers)
        response.raise_for_status()
        return response.json()
    except requests.exceptions.RequestException as e:
        print(f'Error calling /api/v1/builder-orders/: {e}')
        raise

async function postApiV1Builder-orders() {
  try {
    const response = await fetch('https://api.spmc.dev/api/v1/builder-orders/', {
    method: 'POST',
    headers: {
      '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 calling /api/v1/builder-orders/:', error);
    throw error;
  }
}

import requests
from typing import Dict, Any, Optional

def postApiV1Builder-orders() -> Dict[str, Any]:
    """
    Create Builder Order
    
    
    Returns:
        API response as dictionary
    
    Raises:
        requests.exceptions.RequestException: If the request fails
    """
    try:
        url = 'https://api.spmc.dev/api/v1/builder-orders/'
        headers = {
            "Content-Type": "application/json"
    }
        response = requests.post(url, headers=headers)
        response.raise_for_status()
        return response.json()
    except requests.exceptions.RequestException as e:
        print(f'Error calling /api/v1/builder-orders/: {e}')
        raise

async function apiV1Builder-orders(order_id) {
  try {
    const response = await fetch('https://api.spmc.dev/api/v1/builder-orders/example', {
    method: 'GET',
    headers: {
      '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 calling /api/v1/builder-orders/{order_id}:', error);
    throw error;
  }
}

import requests
from typing import Dict, Any, Optional

def apiV1Builder-orders(order_id) -> Dict[str, Any]:
    """
    Get Builder Order
    
    Args:
        order_id: 
    
    Returns:
        API response as dictionary
    
    Raises:
        requests.exceptions.RequestException: If the request fails
    """
    try:
        url = 'https://api.spmc.dev/api/v1/builder-orders/example'
        headers = {
            "Content-Type": "application/json"
    }
        response = requests.get(url, headers=headers)
        response.raise_for_status()
        return response.json()
    except requests.exceptions.RequestException as e:
        print(f'Error calling /api/v1/builder-orders/{order_id}: {e}')
        raise

async function apiV1Groups(group_type, is_template, is_system_generated, search, page, page_size) {
  try {
    const response = await fetch('https://api.spmc.dev/api/v1/groups/', {
    method: 'GET',
    headers: {
      '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 calling /api/v1/groups/:', error);
    throw error;
  }
}

import requests
from typing import Dict, Any, Optional

def apiV1Groups(group_type, is_template, is_system_generated, search, page, page_size) -> Dict[str, Any]:
    """
    List Groups
    
    Args:
        group_type: Filter by group type
        is_template: Filter by template status
        is_system_generated: Filter by system generation status
        search: Search in title and description
        page: Page number
        page_size: Items per page
    
    Returns:
        API response as dictionary
    
    Raises:
        requests.exceptions.RequestException: If the request fails
    """
    try:
        url = 'https://api.spmc.dev/api/v1/groups/'
        headers = {
            "Content-Type": "application/json"
    }
        params = {
            'group_type': group_type,
            'is_template': is_template,
            'is_system_generated': is_system_generated,
            'search': search,
            'page': page,
            'page_size': page_size,
        }
        response = requests.get(url, params=params, headers=headers)
        response.raise_for_status()
        return response.json()
    except requests.exceptions.RequestException as e:
        print(f'Error calling /api/v1/groups/: {e}')
        raise

async function postApiV1Groups() {
  try {
    const response = await fetch('https://api.spmc.dev/api/v1/groups/', {
    method: 'POST',
    headers: {
      '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 calling /api/v1/groups/:', error);
    throw error;
  }
}

import requests
from typing import Dict, Any, Optional

def postApiV1Groups() -> Dict[str, Any]:
    """
    Create Group
    
    
    Returns:
        API response as dictionary
    
    Raises:
        requests.exceptions.RequestException: If the request fails
    """
    try:
        url = 'https://api.spmc.dev/api/v1/groups/'
        headers = {
            "Content-Type": "application/json"
    }
        response = requests.post(url, headers=headers)
        response.raise_for_status()
        return response.json()
    except requests.exceptions.RequestException as e:
        print(f'Error calling /api/v1/groups/: {e}')
        raise

async function postApiV1GroupsFrom-template() {
  try {
    const response = await fetch('https://api.spmc.dev/api/v1/groups/from-template', {
    method: 'POST',
    headers: {
      '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 calling /api/v1/groups/from-template:', error);
    throw error;
  }
}

import requests
from typing import Dict, Any, Optional

def postApiV1GroupsFrom-template() -> Dict[str, Any]:
    """
    Create From Template
    
    
    Returns:
        API response as dictionary
    
    Raises:
        requests.exceptions.RequestException: If the request fails
    """
    try:
        url = 'https://api.spmc.dev/api/v1/groups/from-template'
        headers = {
            "Content-Type": "application/json"
    }
        response = requests.post(url, headers=headers)
        response.raise_for_status()
        return response.json()
    except requests.exceptions.RequestException as e:
        print(f'Error calling /api/v1/groups/from-template: {e}')
        raise

async function postApiV1GroupsResolve-polymarket() {
  try {
    const response = await fetch('https://api.spmc.dev/api/v1/groups/resolve-polymarket', {
    method: 'POST',
    headers: {
      '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 calling /api/v1/groups/resolve-polymarket:', error);
    throw error;
  }
}

import requests
from typing import Dict, Any, Optional

def postApiV1GroupsResolve-polymarket() -> Dict[str, Any]:
    """
    Resolve Polymarket Url
    
    
    Returns:
        API response as dictionary
    
    Raises:
        requests.exceptions.RequestException: If the request fails
    """
    try:
        url = 'https://api.spmc.dev/api/v1/groups/resolve-polymarket'
        headers = {
            "Content-Type": "application/json"
    }
        response = requests.post(url, headers=headers)
        response.raise_for_status()
        return response.json()
    except requests.exceptions.RequestException as e:
        print(f'Error calling /api/v1/groups/resolve-polymarket: {e}')
        raise

async function apiV1GroupsTemplates(group_type, is_active, tags, search, limit, offset) {
  try {
    const response = await fetch('https://api.spmc.dev/api/v1/groups/templates', {
    method: 'GET',
    headers: {
      '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 calling /api/v1/groups/templates:', error);
    throw error;
  }
}

import requests
from typing import Dict, Any, Optional

def apiV1GroupsTemplates(group_type, is_active, tags, search, limit, offset) -> Dict[str, Any]:
    """
    List Templates
    
    Args:
        group_type: Filter by group type
        is_active: Filter by active status
        tags: Filter by tags
        search: Search in name and description
        limit: Maximum results
        offset: Pagination offset
    
    Returns:
        API response as dictionary
    
    Raises:
        requests.exceptions.RequestException: If the request fails
    """
    try:
        url = 'https://api.spmc.dev/api/v1/groups/templates'
        headers = {
            "Content-Type": "application/json"
    }
        params = {
            'group_type': group_type,
            'is_active': is_active,
            'tags': tags,
            'search': search,
            'limit': limit,
            'offset': offset,
        }
        response = requests.get(url, params=params, headers=headers)
        response.raise_for_status()
        return response.json()
    except requests.exceptions.RequestException as e:
        print(f'Error calling /api/v1/groups/templates: {e}')
        raise

async function postApiV1GroupsTemplates() {
  try {
    const response = await fetch('https://api.spmc.dev/api/v1/groups/templates', {
    method: 'POST',
    headers: {
      '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 calling /api/v1/groups/templates:', error);
    throw error;
  }
}

import requests
from typing import Dict, Any, Optional

def postApiV1GroupsTemplates() -> Dict[str, Any]:
    """
    Create Template
    
    
    Returns:
        API response as dictionary
    
    Raises:
        requests.exceptions.RequestException: If the request fails
    """
    try:
        url = 'https://api.spmc.dev/api/v1/groups/templates'
        headers = {
            "Content-Type": "application/json"
    }
        response = requests.post(url, headers=headers)
        response.raise_for_status()
        return response.json()
    except requests.exceptions.RequestException as e:
        print(f'Error calling /api/v1/groups/templates: {e}')
        raise

async function deleteApiV1GroupsTemplates(template_id) {
  try {
    const response = await fetch('https://api.spmc.dev/api/v1/groups/templates/example', {
    method: 'DELETE',
    headers: {
      '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 calling /api/v1/groups/templates/{template_id}:', error);
    throw error;
  }
}

import requests
from typing import Dict, Any, Optional

def deleteApiV1GroupsTemplates(template_id) -> Dict[str, Any]:
    """
    Delete Template
    
    Args:
        template_id: 
    
    Returns:
        API response as dictionary
    
    Raises:
        requests.exceptions.RequestException: If the request fails
    """
    try:
        url = 'https://api.spmc.dev/api/v1/groups/templates/example'
        headers = {
            "Content-Type": "application/json"
    }
        response = requests.delete(url, headers=headers)
        response.raise_for_status()
        return response.json()
    except requests.exceptions.RequestException as e:
        print(f'Error calling /api/v1/groups/templates/{template_id}: {e}')
        raise

async function apiV1GroupsTemplates(template_id) {
  try {
    const response = await fetch('https://api.spmc.dev/api/v1/groups/templates/example', {
    method: 'GET',
    headers: {
      '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 calling /api/v1/groups/templates/{template_id}:', error);
    throw error;
  }
}

import requests
from typing import Dict, Any, Optional

def apiV1GroupsTemplates(template_id) -> Dict[str, Any]:
    """
    Get Template
    
    Args:
        template_id: 
    
    Returns:
        API response as dictionary
    
    Raises:
        requests.exceptions.RequestException: If the request fails
    """
    try:
        url = 'https://api.spmc.dev/api/v1/groups/templates/example'
        headers = {
            "Content-Type": "application/json"
    }
        response = requests.get(url, headers=headers)
        response.raise_for_status()
        return response.json()
    except requests.exceptions.RequestException as e:
        print(f'Error calling /api/v1/groups/templates/{template_id}: {e}')
        raise

async function putApiV1GroupsTemplates(template_id) {
  try {
    const response = await fetch('https://api.spmc.dev/api/v1/groups/templates/example', {
    method: 'PUT',
    headers: {
      '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 calling /api/v1/groups/templates/{template_id}:', error);
    throw error;
  }
}

import requests
from typing import Dict, Any, Optional

def putApiV1GroupsTemplates(template_id) -> Dict[str, Any]:
    """
    Update Template
    
    Args:
        template_id: 
    
    Returns:
        API response as dictionary
    
    Raises:
        requests.exceptions.RequestException: If the request fails
    """
    try:
        url = 'https://api.spmc.dev/api/v1/groups/templates/example'
        headers = {
            "Content-Type": "application/json"
    }
        response = requests.put(url, headers=headers)
        response.raise_for_status()
        return response.json()
    except requests.exceptions.RequestException as e:
        print(f'Error calling /api/v1/groups/templates/{template_id}: {e}')
        raise

async function postApiV1GroupsTemplatesPreview(template_id, limit) {
  try {
    const response = await fetch('https://api.spmc.dev/api/v1/groups/templates/example/preview', {
    method: 'POST',
    headers: {
      '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 calling /api/v1/groups/templates/{template_id}/preview:', error);
    throw error;
  }
}

import requests
from typing import Dict, Any, Optional

def postApiV1GroupsTemplatesPreview(template_id, limit) -> Dict[str, Any]:
    """
    Preview Template
    
    Args:
        template_id: 
        limit: Maximum markets to preview
    
    Returns:
        API response as dictionary
    
    Raises:
        requests.exceptions.RequestException: If the request fails
    """
    try:
        url = 'https://api.spmc.dev/api/v1/groups/templates/example/preview'
        headers = {
            "Content-Type": "application/json"
    }
        params = {
            'limit': limit,
        }
        response = requests.post(url, params=params, headers=headers)
        response.raise_for_status()
        return response.json()
    except requests.exceptions.RequestException as e:
        print(f'Error calling /api/v1/groups/templates/{template_id}/preview: {e}')
        raise

async function deleteApiV1Groups(group_id) {
  try {
    const response = await fetch('https://api.spmc.dev/api/v1/groups/example', {
    method: 'DELETE',
    headers: {
      '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 calling /api/v1/groups/{group_id}:', error);
    throw error;
  }
}

import requests
from typing import Dict, Any, Optional

def deleteApiV1Groups(group_id) -> Dict[str, Any]:
    """
    Delete Group
    
    Args:
        group_id: 
    
    Returns:
        API response as dictionary
    
    Raises:
        requests.exceptions.RequestException: If the request fails
    """
    try:
        url = 'https://api.spmc.dev/api/v1/groups/example'
        headers = {
            "Content-Type": "application/json"
    }
        response = requests.delete(url, headers=headers)
        response.raise_for_status()
        return response.json()
    except requests.exceptions.RequestException as e:
        print(f'Error calling /api/v1/groups/{group_id}: {e}')
        raise

async function apiV1Groups(group_id, include_resolved) {
  try {
    const response = await fetch('https://api.spmc.dev/api/v1/groups/example', {
    method: 'GET',
    headers: {
      '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 calling /api/v1/groups/{group_id}:', error);
    throw error;
  }
}

import requests
from typing import Dict, Any, Optional

def apiV1Groups(group_id, include_resolved) -> Dict[str, Any]:
    """
    Get Group
    
    Args:
        group_id: 
        include_resolved: Include resolved markets in response. By default, resolved markets are filtered out to show only active positions.
    
    Returns:
        API response as dictionary
    
    Raises:
        requests.exceptions.RequestException: If the request fails
    """
    try:
        url = 'https://api.spmc.dev/api/v1/groups/example'
        headers = {
            "Content-Type": "application/json"
    }
        params = {
            'include_resolved': include_resolved,
        }
        response = requests.get(url, params=params, headers=headers)
        response.raise_for_status()
        return response.json()
    except requests.exceptions.RequestException as e:
        print(f'Error calling /api/v1/groups/{group_id}: {e}')
        raise

async function putApiV1Groups(group_id) {
  try {
    const response = await fetch('https://api.spmc.dev/api/v1/groups/example', {
    method: 'PUT',
    headers: {
      '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 calling /api/v1/groups/{group_id}:', error);
    throw error;
  }
}

import requests
from typing import Dict, Any, Optional

def putApiV1Groups(group_id) -> Dict[str, Any]:
    """
    Update Group
    
    Args:
        group_id: 
    
    Returns:
        API response as dictionary
    
    Raises:
        requests.exceptions.RequestException: If the request fails
    """
    try:
        url = 'https://api.spmc.dev/api/v1/groups/example'
        headers = {
            "Content-Type": "application/json"
    }
        response = requests.put(url, headers=headers)
        response.raise_for_status()
        return response.json()
    except requests.exceptions.RequestException as e:
        print(f'Error calling /api/v1/groups/{group_id}: {e}')
        raise

async function apiV1GroupsArbitrage-spread(group_id) {
  try {
    const response = await fetch('https://api.spmc.dev/api/v1/groups/example/arbitrage-spread', {
    method: 'GET',
    headers: {
      '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 calling /api/v1/groups/{group_id}/arbitrage-spread:', error);
    throw error;
  }
}

import requests
from typing import Dict, Any, Optional

def apiV1GroupsArbitrage-spread(group_id) -> Dict[str, Any]:
    """
    Get Arbitrage Spread
    
    Args:
        group_id: 
    
    Returns:
        API response as dictionary
    
    Raises:
        requests.exceptions.RequestException: If the request fails
    """
    try:
        url = 'https://api.spmc.dev/api/v1/groups/example/arbitrage-spread'
        headers = {
            "Content-Type": "application/json"
    }
        response = requests.get(url, headers=headers)
        response.raise_for_status()
        return response.json()
    except requests.exceptions.RequestException as e:
        print(f'Error calling /api/v1/groups/{group_id}/arbitrage-spread: {e}')
        raise

async function apiV1GroupsCorrelation(group_id) {
  try {
    const response = await fetch('https://api.spmc.dev/api/v1/groups/example/correlation', {
    method: 'GET',
    headers: {
      '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 calling /api/v1/groups/{group_id}/correlation:', error);
    throw error;
  }
}

import requests
from typing import Dict, Any, Optional

def apiV1GroupsCorrelation(group_id) -> Dict[str, Any]:
    """
    Get Correlation Data
    
    Args:
        group_id: 
    
    Returns:
        API response as dictionary
    
    Raises:
        requests.exceptions.RequestException: If the request fails
    """
    try:
        url = 'https://api.spmc.dev/api/v1/groups/example/correlation'
        headers = {
            "Content-Type": "application/json"
    }
        response = requests.get(url, headers=headers)
        response.raise_for_status()
        return response.json()
    except requests.exceptions.RequestException as e:
        print(f'Error calling /api/v1/groups/{group_id}/correlation: {e}')
        raise

async function apiV1GroupsIndex-value(group_id, interval, fidelity, start_time, end_time) {
  try {
    const response = await fetch('https://api.spmc.dev/api/v1/groups/example/index-value', {
    method: 'GET',
    headers: {
      '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 calling /api/v1/groups/{group_id}/index-value:', error);
    throw error;
  }
}

import requests
from typing import Dict, Any, Optional

def apiV1GroupsIndex-value(group_id, interval, fidelity, start_time, end_time) -> Dict[str, Any]:
    """
    Get Index Value
    
    Args:
        group_id: 
        interval: Time interval (1m, 1h, 6h, 1d, 1w, max). If provided, returns historical data. Mutually exclusive with start_time/end_time
        fidelity: Resolution in minutes for historical data
        start_time: Start timestamp (Unix UTC) for historical data. Mutually exclusive with interval
        end_time: End timestamp (Unix UTC) for historical data. Mutually exclusive with interval
    
    Returns:
        API response as dictionary
    
    Raises:
        requests.exceptions.RequestException: If the request fails
    """
    try:
        url = 'https://api.spmc.dev/api/v1/groups/example/index-value'
        headers = {
            "Content-Type": "application/json"
    }
        params = {
            'interval': interval,
            'fidelity': fidelity,
            'start_time': start_time,
            'end_time': end_time,
        }
        response = requests.get(url, params=params, headers=headers)
        response.raise_for_status()
        return response.json()
    except requests.exceptions.RequestException as e:
        print(f'Error calling /api/v1/groups/{group_id}/index-value: {e}')
        raise

async function postApiV1GroupsMarkets(group_id) {
  try {
    const response = await fetch('https://api.spmc.dev/api/v1/groups/example/markets', {
    method: 'POST',
    headers: {
      '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 calling /api/v1/groups/{group_id}/markets:', error);
    throw error;
  }
}

import requests
from typing import Dict, Any, Optional

def postApiV1GroupsMarkets(group_id) -> Dict[str, Any]:
    """
    Add Markets To Group
    
    Args:
        group_id: 
    
    Returns:
        API response as dictionary
    
    Raises:
        requests.exceptions.RequestException: If the request fails
    """
    try:
        url = 'https://api.spmc.dev/api/v1/groups/example/markets'
        headers = {
            "Content-Type": "application/json"
    }
        response = requests.post(url, headers=headers)
        response.raise_for_status()
        return response.json()
    except requests.exceptions.RequestException as e:
        print(f'Error calling /api/v1/groups/{group_id}/markets: {e}')
        raise

async function postApiV1GroupsMarketsFrom-polymarket(group_id) {
  try {
    const response = await fetch('https://api.spmc.dev/api/v1/groups/example/markets/from-polymarket', {
    method: 'POST',
    headers: {
      '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 calling /api/v1/groups/{group_id}/markets/from-polymarket:', error);
    throw error;
  }
}

import requests
from typing import Dict, Any, Optional

def postApiV1GroupsMarketsFrom-polymarket(group_id) -> Dict[str, Any]:
    """
    Add Polymarket To Group
    
    Args:
        group_id: 
    
    Returns:
        API response as dictionary
    
    Raises:
        requests.exceptions.RequestException: If the request fails
    """
    try:
        url = 'https://api.spmc.dev/api/v1/groups/example/markets/from-polymarket'
        headers = {
            "Content-Type": "application/json"
    }
        response = requests.post(url, headers=headers)
        response.raise_for_status()
        return response.json()
    except requests.exceptions.RequestException as e:
        print(f'Error calling /api/v1/groups/{group_id}/markets/from-polymarket: {e}')
        raise

async function deleteApiV1GroupsMarkets(group_id, market_id) {
  try {
    const response = await fetch('https://api.spmc.dev/api/v1/groups/example/markets/example', {
    method: 'DELETE',
    headers: {
      '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 calling /api/v1/groups/{group_id}/markets/{market_id}:', error);
    throw error;
  }
}

import requests
from typing import Dict, Any, Optional

def deleteApiV1GroupsMarkets(group_id, market_id) -> Dict[str, Any]:
    """
    Remove Market From Group
    
    Args:
        group_id: 
        market_id: 
    
    Returns:
        API response as dictionary
    
    Raises:
        requests.exceptions.RequestException: If the request fails
    """
    try:
        url = 'https://api.spmc.dev/api/v1/groups/example/markets/example'
        headers = {
            "Content-Type": "application/json"
    }
        response = requests.delete(url, headers=headers)
        response.raise_for_status()
        return response.json()
    except requests.exceptions.RequestException as e:
        print(f'Error calling /api/v1/groups/{group_id}/markets/{market_id}: {e}')
        raise

async function putApiV1GroupsMarkets(group_id, market_id) {
  try {
    const response = await fetch('https://api.spmc.dev/api/v1/groups/example/markets/example', {
    method: 'PUT',
    headers: {
      '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 calling /api/v1/groups/{group_id}/markets/{market_id}:', error);
    throw error;
  }
}

import requests
from typing import Dict, Any, Optional

def putApiV1GroupsMarkets(group_id, market_id) -> Dict[str, Any]:
    """
    Update Market In Group
    
    Args:
        group_id: 
        market_id: 
    
    Returns:
        API response as dictionary
    
    Raises:
        requests.exceptions.RequestException: If the request fails
    """
    try:
        url = 'https://api.spmc.dev/api/v1/groups/example/markets/example'
        headers = {
            "Content-Type": "application/json"
    }
        response = requests.put(url, headers=headers)
        response.raise_for_status()
        return response.json()
    except requests.exceptions.RequestException as e:
        print(f'Error calling /api/v1/groups/{group_id}/markets/{market_id}: {e}')
        raise

async function apiV1GroupsMembership-history(group_id, start_time, end_time, limit, action_type, include_resolutions) {
  try {
    const response = await fetch('https://api.spmc.dev/api/v1/groups/example/membership-history', {
    method: 'GET',
    headers: {
      '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 calling /api/v1/groups/{group_id}/membership-history:', error);
    throw error;
  }
}

import requests
from typing import Dict, Any, Optional

def apiV1GroupsMembership-history(group_id, start_time, end_time, limit, action_type, include_resolutions) -> Dict[str, Any]:
    """
    Get Membership History
    
    Args:
        group_id: 
        start_time: Unix timestamp (start filter)
        end_time: Unix timestamp (end filter)
        limit: Maximum number of changes
        action_type: Filter by action type: 'manual' (added, removed, weight_changed), 'automatic' (resolved_win, resolved_loss, resolved_invalid), or 'all' for everything
        include_resolutions: Include resolution events (resolved_win, resolved_loss, resolved_invalid) in response. Set to false to show only manual changes.
    
    Returns:
        API response as dictionary
    
    Raises:
        requests.exceptions.RequestException: If the request fails
    """
    try:
        url = 'https://api.spmc.dev/api/v1/groups/example/membership-history'
        headers = {
            "Content-Type": "application/json"
    }
        params = {
            'start_time': start_time,
            'end_time': end_time,
            'limit': limit,
            'action_type': action_type,
            'include_resolutions': include_resolutions,
        }
        response = requests.get(url, params=params, headers=headers)
        response.raise_for_status()
        return response.json()
    except requests.exceptions.RequestException as e:
        print(f'Error calling /api/v1/groups/{group_id}/membership-history: {e}')
        raise

async function apiV1GroupsMetrics(group_id) {
  try {
    const response = await fetch('https://api.spmc.dev/api/v1/groups/example/metrics', {
    method: 'GET',
    headers: {
      '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 calling /api/v1/groups/{group_id}/metrics:', error);
    throw error;
  }
}

import requests
from typing import Dict, Any, Optional

def apiV1GroupsMetrics(group_id) -> Dict[str, Any]:
    """
    Get Group Metrics
    
    Args:
        group_id: 
    
    Returns:
        API response as dictionary
    
    Raises:
        requests.exceptions.RequestException: If the request fails
    """
    try:
        url = 'https://api.spmc.dev/api/v1/groups/example/metrics'
        headers = {
            "Content-Type": "application/json"
    }
        response = requests.get(url, headers=headers)
        response.raise_for_status()
        return response.json()
    except requests.exceptions.RequestException as e:
        print(f'Error calling /api/v1/groups/{group_id}/metrics: {e}')
        raise

async function apiV1GroupsNav-history(group_id, start_ts, end_ts, normalized) {
  try {
    const response = await fetch('https://api.spmc.dev/api/v1/groups/example/nav-history', {
    method: 'GET',
    headers: {
      '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 calling /api/v1/groups/{group_id}/nav-history:', error);
    throw error;
  }
}

import requests
from typing import Dict, Any, Optional

def apiV1GroupsNav-history(group_id, start_ts, end_ts, normalized) -> Dict[str, Any]:
    """
    Get Nav History
    
    Args:
        group_id: 
        start_ts: Start timestamp (Unix seconds). Defaults to 7 days ago if not provided.
        end_ts: End timestamp (Unix seconds). Defaults to now if not provided.
        normalized: If true, return normalized NAV (1.0 at inception). If false, return absolute NAV.
    
    Returns:
        API response as dictionary
    
    Raises:
        requests.exceptions.RequestException: If the request fails
    """
    try:
        url = 'https://api.spmc.dev/api/v1/groups/example/nav-history'
        headers = {
            "Content-Type": "application/json"
    }
        params = {
            'start_ts': start_ts,
            'end_ts': end_ts,
            'normalized': normalized,
        }
        response = requests.get(url, params=params, headers=headers)
        response.raise_for_status()
        return response.json()
    except requests.exceptions.RequestException as e:
        print(f'Error calling /api/v1/groups/{group_id}/nav-history: {e}')
        raise

async function apiV1GroupsNav-latest(group_id, include_position_details) {
  try {
    const response = await fetch('https://api.spmc.dev/api/v1/groups/example/nav-latest', {
    method: 'GET',
    headers: {
      '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 calling /api/v1/groups/{group_id}/nav-latest:', error);
    throw error;
  }
}

import requests
from typing import Dict, Any, Optional

def apiV1GroupsNav-latest(group_id, include_position_details) -> Dict[str, Any]:
    """
    Get Latest Nav
    
    Args:
        group_id: 
        include_position_details: Include position-level cost basis and PnL details
    
    Returns:
        API response as dictionary
    
    Raises:
        requests.exceptions.RequestException: If the request fails
    """
    try:
        url = 'https://api.spmc.dev/api/v1/groups/example/nav-latest'
        headers = {
            "Content-Type": "application/json"
    }
        params = {
            'include_position_details': include_position_details,
        }
        response = requests.get(url, params=params, headers=headers)
        response.raise_for_status()
        return response.json()
    except requests.exceptions.RequestException as e:
        print(f'Error calling /api/v1/groups/{group_id}/nav-latest: {e}')
        raise

async function apiV1GroupsPerformance(group_id, period) {
  try {
    const response = await fetch('https://api.spmc.dev/api/v1/groups/example/performance', {
    method: 'GET',
    headers: {
      '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 calling /api/v1/groups/{group_id}/performance:', error);
    throw error;
  }
}

import requests
from typing import Dict, Any, Optional

def apiV1GroupsPerformance(group_id, period) -> Dict[str, Any]:
    """
    Get Group Performance
    
    Args:
        group_id: 
        period: Time period: 1h, 24h, 7d, 30d, all
    
    Returns:
        API response as dictionary
    
    Raises:
        requests.exceptions.RequestException: If the request fails
    """
    try:
        url = 'https://api.spmc.dev/api/v1/groups/example/performance'
        headers = {
            "Content-Type": "application/json"
    }
        params = {
            'period': period,
        }
        response = requests.get(url, params=params, headers=headers)
        response.raise_for_status()
        return response.json()
    except requests.exceptions.RequestException as e:
        print(f'Error calling /api/v1/groups/{group_id}/performance: {e}')
        raise

async function apiV1GroupsPortfolio-value(group_id) {
  try {
    const response = await fetch('https://api.spmc.dev/api/v1/groups/example/portfolio-value', {
    method: 'GET',
    headers: {
      '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 calling /api/v1/groups/{group_id}/portfolio-value:', error);
    throw error;
  }
}

import requests
from typing import Dict, Any, Optional

def apiV1GroupsPortfolio-value(group_id) -> Dict[str, Any]:
    """
    Get Portfolio Value
    
    Args:
        group_id: 
    
    Returns:
        API response as dictionary
    
    Raises:
        requests.exceptions.RequestException: If the request fails
    """
    try:
        url = 'https://api.spmc.dev/api/v1/groups/example/portfolio-value'
        headers = {
            "Content-Type": "application/json"
    }
        response = requests.get(url, headers=headers)
        response.raise_for_status()
        return response.json()
    except requests.exceptions.RequestException as e:
        print(f'Error calling /api/v1/groups/{group_id}/portfolio-value: {e}')
        raise

async function postApiV1GroupsRebalance(group_id) {
  try {
    const response = await fetch('https://api.spmc.dev/api/v1/groups/example/rebalance', {
    method: 'POST',
    headers: {
      '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 calling /api/v1/groups/{group_id}/rebalance:', error);
    throw error;
  }
}

import requests
from typing import Dict, Any, Optional

def postApiV1GroupsRebalance(group_id) -> Dict[str, Any]:
    """
    Rebalance Portfolio
    
    Args:
        group_id: 
    
    Returns:
        API response as dictionary
    
    Raises:
        requests.exceptions.RequestException: If the request fails
    """
    try:
        url = 'https://api.spmc.dev/api/v1/groups/example/rebalance'
        headers = {
            "Content-Type": "application/json"
    }
        response = requests.post(url, headers=headers)
        response.raise_for_status()
        return response.json()
    except requests.exceptions.RequestException as e:
        print(f'Error calling /api/v1/groups/{group_id}/rebalance: {e}')
        raise

async function apiV1GroupsRebalance-history(group_id, start_time, end_time, limit) {
  try {
    const response = await fetch('https://api.spmc.dev/api/v1/groups/example/rebalance-history', {
    method: 'GET',
    headers: {
      '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 calling /api/v1/groups/{group_id}/rebalance-history:', error);
    throw error;
  }
}

import requests
from typing import Dict, Any, Optional

def apiV1GroupsRebalance-history(group_id, start_time, end_time, limit) -> Dict[str, Any]:
    """
    Get Rebalance History
    
    Args:
        group_id: 
        start_time: Unix timestamp in seconds (start filter)
        end_time: Unix timestamp in seconds (end filter)
        limit: Maximum number of rebalances to return
    
    Returns:
        API response as dictionary
    
    Raises:
        requests.exceptions.RequestException: If the request fails
    """
    try:
        url = 'https://api.spmc.dev/api/v1/groups/example/rebalance-history'
        headers = {
            "Content-Type": "application/json"
    }
        params = {
            'start_time': start_time,
            'end_time': end_time,
            'limit': limit,
        }
        response = requests.get(url, params=params, headers=headers)
        response.raise_for_status()
        return response.json()
    except requests.exceptions.RequestException as e:
        print(f'Error calling /api/v1/groups/{group_id}/rebalance-history: {e}')
        raise

async function apiV1MonitoringKalshiKalshi-status() {
  try {
    const response = await fetch('https://api.spmc.dev/api/v1/monitoring/kalshi/kalshi-status', {
    method: 'GET',
    headers: {
      '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 calling /api/v1/monitoring/kalshi/kalshi-status:', error);
    throw error;
  }
}

import requests
from typing import Dict, Any, Optional

def apiV1MonitoringKalshiKalshi-status() -> Dict[str, Any]:
    """
    Get Kalshi Status
    
    
    Returns:
        API response as dictionary
    
    Raises:
        requests.exceptions.RequestException: If the request fails
    """
    try:
        url = 'https://api.spmc.dev/api/v1/monitoring/kalshi/kalshi-status'
        headers = {
            "Content-Type": "application/json"
    }
        response = requests.get(url, headers=headers)
        response.raise_for_status()
        return response.json()
    except requests.exceptions.RequestException as e:
        print(f'Error calling /api/v1/monitoring/kalshi/kalshi-status: {e}')
        raise

async function apiV1MonitoringKalshiMetrics() {
  try {
    const response = await fetch('https://api.spmc.dev/api/v1/monitoring/kalshi/metrics', {
    method: 'GET',
    headers: {
      '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 calling /api/v1/monitoring/kalshi/metrics:', error);
    throw error;
  }
}

import requests
from typing import Dict, Any, Optional

def apiV1MonitoringKalshiMetrics() -> Dict[str, Any]:
    """
    Get Kalshi Metrics
    
    
    Returns:
        API response as dictionary
    
    Raises:
        requests.exceptions.RequestException: If the request fails
    """
    try:
        url = 'https://api.spmc.dev/api/v1/monitoring/kalshi/metrics'
        headers = {
            "Content-Type": "application/json"
    }
        response = requests.get(url, headers=headers)
        response.raise_for_status()
        return response.json()
    except requests.exceptions.RequestException as e:
        print(f'Error calling /api/v1/monitoring/kalshi/metrics: {e}')
        raise

async function apiV1MonitoringKalshiMetricsScaling-readiness(target_markets) {
  try {
    const response = await fetch('https://api.spmc.dev/api/v1/monitoring/kalshi/metrics/scaling-readiness', {
    method: 'GET',
    headers: {
      '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 calling /api/v1/monitoring/kalshi/metrics/scaling-readiness:', error);
    throw error;
  }
}

import requests
from typing import Dict, Any, Optional

def apiV1MonitoringKalshiMetricsScaling-readiness(target_markets) -> Dict[str, Any]:
    """
    Check Scaling Readiness
    
    Args:
        target_markets: 
    
    Returns:
        API response as dictionary
    
    Raises:
        requests.exceptions.RequestException: If the request fails
    """
    try:
        url = 'https://api.spmc.dev/api/v1/monitoring/kalshi/metrics/scaling-readiness'
        headers = {
            "Content-Type": "application/json"
    }
        params = {
            'target_markets': target_markets,
        }
        response = requests.get(url, params=params, headers=headers)
        response.raise_for_status()
        return response.json()
    except requests.exceptions.RequestException as e:
        print(f'Error calling /api/v1/monitoring/kalshi/metrics/scaling-readiness: {e}')
        raise

async function apiV1MonitoringKalshiOrderbook-status() {
  try {
    const response = await fetch('https://api.spmc.dev/api/v1/monitoring/kalshi/orderbook-status', {
    method: 'GET',
    headers: {
      '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 calling /api/v1/monitoring/kalshi/orderbook-status:', error);
    throw error;
  }
}

import requests
from typing import Dict, Any, Optional

def apiV1MonitoringKalshiOrderbook-status() -> Dict[str, Any]:
    """
    Get Kalshi Orderbook Status
    
    
    Returns:
        API response as dictionary
    
    Raises:
        requests.exceptions.RequestException: If the request fails
    """
    try:
        url = 'https://api.spmc.dev/api/v1/monitoring/kalshi/orderbook-status'
        headers = {
            "Content-Type": "application/json"
    }
        response = requests.get(url, headers=headers)
        response.raise_for_status()
        return response.json()
    except requests.exceptions.RequestException as e:
        print(f'Error calling /api/v1/monitoring/kalshi/orderbook-status: {e}')
        raise

async function apiV1MonitoringKalshiPipeline() {
  try {
    const response = await fetch('https://api.spmc.dev/api/v1/monitoring/kalshi/pipeline', {
    method: 'GET',
    headers: {
      '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 calling /api/v1/monitoring/kalshi/pipeline:', error);
    throw error;
  }
}

import requests
from typing import Dict, Any, Optional

def apiV1MonitoringKalshiPipeline() -> Dict[str, Any]:
    """
    Get Kalshi Pipeline Status
    
    
    Returns:
        API response as dictionary
    
    Raises:
        requests.exceptions.RequestException: If the request fails
    """
    try:
        url = 'https://api.spmc.dev/api/v1/monitoring/kalshi/pipeline'
        headers = {
            "Content-Type": "application/json"
    }
        response = requests.get(url, headers=headers)
        response.raise_for_status()
        return response.json()
    except requests.exceptions.RequestException as e:
        print(f'Error calling /api/v1/monitoring/kalshi/pipeline: {e}')
        raise

async function apiV1MonitoringKalshiPipelineLogs(minutes) {
  try {
    const response = await fetch('https://api.spmc.dev/api/v1/monitoring/kalshi/pipeline/logs', {
    method: 'GET',
    headers: {
      '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 calling /api/v1/monitoring/kalshi/pipeline/logs:', error);
    throw error;
  }
}

import requests
from typing import Dict, Any, Optional

def apiV1MonitoringKalshiPipelineLogs(minutes) -> Dict[str, Any]:
    """
    Get Kalshi Pipeline Logs
    
    Args:
        minutes: 
    
    Returns:
        API response as dictionary
    
    Raises:
        requests.exceptions.RequestException: If the request fails
    """
    try:
        url = 'https://api.spmc.dev/api/v1/monitoring/kalshi/pipeline/logs'
        headers = {
            "Content-Type": "application/json"
    }
        params = {
            'minutes': minutes,
        }
        response = requests.get(url, params=params, headers=headers)
        response.raise_for_status()
        return response.json()
    except requests.exceptions.RequestException as e:
        print(f'Error calling /api/v1/monitoring/kalshi/pipeline/logs: {e}')
        raise

async function apiV1MonitoringKalshiStatus() {
  try {
    const response = await fetch('https://api.spmc.dev/api/v1/monitoring/kalshi/status', {
    method: 'GET',
    headers: {
      '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 calling /api/v1/monitoring/kalshi/status:', error);
    throw error;
  }
}

import requests
from typing import Dict, Any, Optional

def apiV1MonitoringKalshiStatus() -> Dict[str, Any]:
    """
    Get Kalshi Status
    
    
    Returns:
        API response as dictionary
    
    Raises:
        requests.exceptions.RequestException: If the request fails
    """
    try:
        url = 'https://api.spmc.dev/api/v1/monitoring/kalshi/status'
        headers = {
            "Content-Type": "application/json"
    }
        response = requests.get(url, headers=headers)
        response.raise_for_status()
        return response.json()
    except requests.exceptions.RequestException as e:
        print(f'Error calling /api/v1/monitoring/kalshi/status: {e}')
        raise

async function apiV1MonitoringKalshiStatusCan-scale(target_markets) {
  try {
    const response = await fetch('https://api.spmc.dev/api/v1/monitoring/kalshi/status/can-scale', {
    method: 'GET',
    headers: {
      '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 calling /api/v1/monitoring/kalshi/status/can-scale:', error);
    throw error;
  }
}

import requests
from typing import Dict, Any, Optional

def apiV1MonitoringKalshiStatusCan-scale(target_markets) -> Dict[str, Any]:
    """
    Check Can Scale
    
    Args:
        target_markets: 
    
    Returns:
        API response as dictionary
    
    Raises:
        requests.exceptions.RequestException: If the request fails
    """
    try:
        url = 'https://api.spmc.dev/api/v1/monitoring/kalshi/status/can-scale'
        headers = {
            "Content-Type": "application/json"
    }
        params = {
            'target_markets': target_markets,
        }
        response = requests.get(url, params=params, headers=headers)
        response.raise_for_status()
        return response.json()
    except requests.exceptions.RequestException as e:
        print(f'Error calling /api/v1/monitoring/kalshi/status/can-scale: {e}')
        raise

async function apiV1MonitoringKalshiKalshi-status() {
  try {
    const response = await fetch('https://api.spmc.dev/api/v1/monitoring/kalshi/kalshi-status', {
    method: 'GET',
    headers: {
      '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 calling /api/v1/monitoring/kalshi/kalshi-status:', error);
    throw error;
  }
}

import requests
from typing import Dict, Any, Optional

def apiV1MonitoringKalshiKalshi-status() -> Dict[str, Any]:
    """
    Get Kalshi Status
    
    
    Returns:
        API response as dictionary
    
    Raises:
        requests.exceptions.RequestException: If the request fails
    """
    try:
        url = 'https://api.spmc.dev/api/v1/monitoring/kalshi/kalshi-status'
        headers = {
            "Content-Type": "application/json"
    }
        response = requests.get(url, headers=headers)
        response.raise_for_status()
        return response.json()
    except requests.exceptions.RequestException as e:
        print(f'Error calling /api/v1/monitoring/kalshi/kalshi-status: {e}')
        raise

async function apiV1MonitoringKalshiMetrics() {
  try {
    const response = await fetch('https://api.spmc.dev/api/v1/monitoring/kalshi/metrics', {
    method: 'GET',
    headers: {
      '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 calling /api/v1/monitoring/kalshi/metrics:', error);
    throw error;
  }
}

import requests
from typing import Dict, Any, Optional

def apiV1MonitoringKalshiMetrics() -> Dict[str, Any]:
    """
    Get Kalshi Metrics
    
    
    Returns:
        API response as dictionary
    
    Raises:
        requests.exceptions.RequestException: If the request fails
    """
    try:
        url = 'https://api.spmc.dev/api/v1/monitoring/kalshi/metrics'
        headers = {
            "Content-Type": "application/json"
    }
        response = requests.get(url, headers=headers)
        response.raise_for_status()
        return response.json()
    except requests.exceptions.RequestException as e:
        print(f'Error calling /api/v1/monitoring/kalshi/metrics: {e}')
        raise

async function apiV1MonitoringKalshiMetricsScaling-readiness(target_markets) {
  try {
    const response = await fetch('https://api.spmc.dev/api/v1/monitoring/kalshi/metrics/scaling-readiness', {
    method: 'GET',
    headers: {
      '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 calling /api/v1/monitoring/kalshi/metrics/scaling-readiness:', error);
    throw error;
  }
}

import requests
from typing import Dict, Any, Optional

def apiV1MonitoringKalshiMetricsScaling-readiness(target_markets) -> Dict[str, Any]:
    """
    Check Scaling Readiness
    
    Args:
        target_markets: 
    
    Returns:
        API response as dictionary
    
    Raises:
        requests.exceptions.RequestException: If the request fails
    """
    try:
        url = 'https://api.spmc.dev/api/v1/monitoring/kalshi/metrics/scaling-readiness'
        headers = {
            "Content-Type": "application/json"
    }
        params = {
            'target_markets': target_markets,
        }
        response = requests.get(url, params=params, headers=headers)
        response.raise_for_status()
        return response.json()
    except requests.exceptions.RequestException as e:
        print(f'Error calling /api/v1/monitoring/kalshi/metrics/scaling-readiness: {e}')
        raise

async function apiV1MonitoringKalshiOrderbook-status() {
  try {
    const response = await fetch('https://api.spmc.dev/api/v1/monitoring/kalshi/orderbook-status', {
    method: 'GET',
    headers: {
      '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 calling /api/v1/monitoring/kalshi/orderbook-status:', error);
    throw error;
  }
}

import requests
from typing import Dict, Any, Optional

def apiV1MonitoringKalshiOrderbook-status() -> Dict[str, Any]:
    """
    Get Kalshi Orderbook Status
    
    
    Returns:
        API response as dictionary
    
    Raises:
        requests.exceptions.RequestException: If the request fails
    """
    try:
        url = 'https://api.spmc.dev/api/v1/monitoring/kalshi/orderbook-status'
        headers = {
            "Content-Type": "application/json"
    }
        response = requests.get(url, headers=headers)
        response.raise_for_status()
        return response.json()
    except requests.exceptions.RequestException as e:
        print(f'Error calling /api/v1/monitoring/kalshi/orderbook-status: {e}')
        raise

async function apiV1MonitoringKalshiPipeline() {
  try {
    const response = await fetch('https://api.spmc.dev/api/v1/monitoring/kalshi/pipeline', {
    method: 'GET',
    headers: {
      '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 calling /api/v1/monitoring/kalshi/pipeline:', error);
    throw error;
  }
}

import requests
from typing import Dict, Any, Optional

def apiV1MonitoringKalshiPipeline() -> Dict[str, Any]:
    """
    Get Kalshi Pipeline Status
    
    
    Returns:
        API response as dictionary
    
    Raises:
        requests.exceptions.RequestException: If the request fails
    """
    try:
        url = 'https://api.spmc.dev/api/v1/monitoring/kalshi/pipeline'
        headers = {
            "Content-Type": "application/json"
    }
        response = requests.get(url, headers=headers)
        response.raise_for_status()
        return response.json()
    except requests.exceptions.RequestException as e:
        print(f'Error calling /api/v1/monitoring/kalshi/pipeline: {e}')
        raise

async function apiV1MonitoringKalshiPipelineLogs(minutes) {
  try {
    const response = await fetch('https://api.spmc.dev/api/v1/monitoring/kalshi/pipeline/logs', {
    method: 'GET',
    headers: {
      '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 calling /api/v1/monitoring/kalshi/pipeline/logs:', error);
    throw error;
  }
}

import requests
from typing import Dict, Any, Optional

def apiV1MonitoringKalshiPipelineLogs(minutes) -> Dict[str, Any]:
    """
    Get Kalshi Pipeline Logs
    
    Args:
        minutes: 
    
    Returns:
        API response as dictionary
    
    Raises:
        requests.exceptions.RequestException: If the request fails
    """
    try:
        url = 'https://api.spmc.dev/api/v1/monitoring/kalshi/pipeline/logs'
        headers = {
            "Content-Type": "application/json"
    }
        params = {
            'minutes': minutes,
        }
        response = requests.get(url, params=params, headers=headers)
        response.raise_for_status()
        return response.json()
    except requests.exceptions.RequestException as e:
        print(f'Error calling /api/v1/monitoring/kalshi/pipeline/logs: {e}')
        raise

async function apiV1MonitoringKalshiStatus() {
  try {
    const response = await fetch('https://api.spmc.dev/api/v1/monitoring/kalshi/status', {
    method: 'GET',
    headers: {
      '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 calling /api/v1/monitoring/kalshi/status:', error);
    throw error;
  }
}

import requests
from typing import Dict, Any, Optional

def apiV1MonitoringKalshiStatus() -> Dict[str, Any]:
    """
    Get Kalshi Status
    
    
    Returns:
        API response as dictionary
    
    Raises:
        requests.exceptions.RequestException: If the request fails
    """
    try:
        url = 'https://api.spmc.dev/api/v1/monitoring/kalshi/status'
        headers = {
            "Content-Type": "application/json"
    }
        response = requests.get(url, headers=headers)
        response.raise_for_status()
        return response.json()
    except requests.exceptions.RequestException as e:
        print(f'Error calling /api/v1/monitoring/kalshi/status: {e}')
        raise

async function apiV1MonitoringKalshiStatusCan-scale(target_markets) {
  try {
    const response = await fetch('https://api.spmc.dev/api/v1/monitoring/kalshi/status/can-scale', {
    method: 'GET',
    headers: {
      '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 calling /api/v1/monitoring/kalshi/status/can-scale:', error);
    throw error;
  }
}

import requests
from typing import Dict, Any, Optional

def apiV1MonitoringKalshiStatusCan-scale(target_markets) -> Dict[str, Any]:
    """
    Check Can Scale
    
    Args:
        target_markets: 
    
    Returns:
        API response as dictionary
    
    Raises:
        requests.exceptions.RequestException: If the request fails
    """
    try:
        url = 'https://api.spmc.dev/api/v1/monitoring/kalshi/status/can-scale'
        headers = {
            "Content-Type": "application/json"
    }
        params = {
            'target_markets': target_markets,
        }
        response = requests.get(url, params=params, headers=headers)
        response.raise_for_status()
        return response.json()
    except requests.exceptions.RequestException as e:
        print(f'Error calling /api/v1/monitoring/kalshi/status/can-scale: {e}')
        raise

async function apiV1MonitoringPolymarketMetrics() {
  try {
    const response = await fetch('https://api.spmc.dev/api/v1/monitoring/polymarket/metrics', {
    method: 'GET',
    headers: {
      '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 calling /api/v1/monitoring/polymarket/metrics:', error);
    throw error;
  }
}

import requests
from typing import Dict, Any, Optional

def apiV1MonitoringPolymarketMetrics() -> Dict[str, Any]:
    """
    Get Polymarket Metrics
    
    
    Returns:
        API response as dictionary
    
    Raises:
        requests.exceptions.RequestException: If the request fails
    """
    try:
        url = 'https://api.spmc.dev/api/v1/monitoring/polymarket/metrics'
        headers = {
            "Content-Type": "application/json"
    }
        response = requests.get(url, headers=headers)
        response.raise_for_status()
        return response.json()
    except requests.exceptions.RequestException as e:
        print(f'Error calling /api/v1/monitoring/polymarket/metrics: {e}')
        raise

async function apiV1MonitoringPolymarketOrderbook-status() {
  try {
    const response = await fetch('https://api.spmc.dev/api/v1/monitoring/polymarket/orderbook-status', {
    method: 'GET',
    headers: {
      '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 calling /api/v1/monitoring/polymarket/orderbook-status:', error);
    throw error;
  }
}

import requests
from typing import Dict, Any, Optional

def apiV1MonitoringPolymarketOrderbook-status() -> Dict[str, Any]:
    """
    Get Polymarket Orderbook Status
    
    
    Returns:
        API response as dictionary
    
    Raises:
        requests.exceptions.RequestException: If the request fails
    """
    try:
        url = 'https://api.spmc.dev/api/v1/monitoring/polymarket/orderbook-status'
        headers = {
            "Content-Type": "application/json"
    }
        response = requests.get(url, headers=headers)
        response.raise_for_status()
        return response.json()
    except requests.exceptions.RequestException as e:
        print(f'Error calling /api/v1/monitoring/polymarket/orderbook-status: {e}')
        raise

async function apiV1MonitoringPolymarketStatus() {
  try {
    const response = await fetch('https://api.spmc.dev/api/v1/monitoring/polymarket/status', {
    method: 'GET',
    headers: {
      '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 calling /api/v1/monitoring/polymarket/status:', error);
    throw error;
  }
}

import requests
from typing import Dict, Any, Optional

def apiV1MonitoringPolymarketStatus() -> Dict[str, Any]:
    """
    Get Polymarket Status
    
    
    Returns:
        API response as dictionary
    
    Raises:
        requests.exceptions.RequestException: If the request fails
    """
    try:
        url = 'https://api.spmc.dev/api/v1/monitoring/polymarket/status'
        headers = {
            "Content-Type": "application/json"
    }
        response = requests.get(url, headers=headers)
        response.raise_for_status()
        return response.json()
    except requests.exceptions.RequestException as e:
        print(f'Error calling /api/v1/monitoring/polymarket/status: {e}')
        raise

async function apiV1MonitoringPolymarketSubscription-analysis() {
  try {
    const response = await fetch('https://api.spmc.dev/api/v1/monitoring/polymarket/subscription-analysis', {
    method: 'GET',
    headers: {
      '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 calling /api/v1/monitoring/polymarket/subscription-analysis:', error);
    throw error;
  }
}

import requests
from typing import Dict, Any, Optional

def apiV1MonitoringPolymarketSubscription-analysis() -> Dict[str, Any]:
    """
    Analyze Polymarket Subscriptions
    
    
    Returns:
        API response as dictionary
    
    Raises:
        requests.exceptions.RequestException: If the request fails
    """
    try:
        url = 'https://api.spmc.dev/api/v1/monitoring/polymarket/subscription-analysis'
        headers = {
            "Content-Type": "application/json"
    }
        response = requests.get(url, headers=headers)
        response.raise_for_status()
        return response.json()
    except requests.exceptions.RequestException as e:
        print(f'Error calling /api/v1/monitoring/polymarket/subscription-analysis: {e}')
        raise

async function apiV1MonitoringPolymarketMetrics() {
  try {
    const response = await fetch('https://api.spmc.dev/api/v1/monitoring/polymarket/metrics', {
    method: 'GET',
    headers: {
      '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 calling /api/v1/monitoring/polymarket/metrics:', error);
    throw error;
  }
}

import requests
from typing import Dict, Any, Optional

def apiV1MonitoringPolymarketMetrics() -> Dict[str, Any]:
    """
    Get Polymarket Metrics
    
    
    Returns:
        API response as dictionary
    
    Raises:
        requests.exceptions.RequestException: If the request fails
    """
    try:
        url = 'https://api.spmc.dev/api/v1/monitoring/polymarket/metrics'
        headers = {
            "Content-Type": "application/json"
    }
        response = requests.get(url, headers=headers)
        response.raise_for_status()
        return response.json()
    except requests.exceptions.RequestException as e:
        print(f'Error calling /api/v1/monitoring/polymarket/metrics: {e}')
        raise

async function apiV1MonitoringPolymarketOrderbook-status() {
  try {
    const response = await fetch('https://api.spmc.dev/api/v1/monitoring/polymarket/orderbook-status', {
    method: 'GET',
    headers: {
      '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 calling /api/v1/monitoring/polymarket/orderbook-status:', error);
    throw error;
  }
}

import requests
from typing import Dict, Any, Optional

def apiV1MonitoringPolymarketOrderbook-status() -> Dict[str, Any]:
    """
    Get Polymarket Orderbook Status
    
    
    Returns:
        API response as dictionary
    
    Raises:
        requests.exceptions.RequestException: If the request fails
    """
    try:
        url = 'https://api.spmc.dev/api/v1/monitoring/polymarket/orderbook-status'
        headers = {
            "Content-Type": "application/json"
    }
        response = requests.get(url, headers=headers)
        response.raise_for_status()
        return response.json()
    except requests.exceptions.RequestException as e:
        print(f'Error calling /api/v1/monitoring/polymarket/orderbook-status: {e}')
        raise

async function apiV1MonitoringPolymarketStatus() {
  try {
    const response = await fetch('https://api.spmc.dev/api/v1/monitoring/polymarket/status', {
    method: 'GET',
    headers: {
      '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 calling /api/v1/monitoring/polymarket/status:', error);
    throw error;
  }
}

import requests
from typing import Dict, Any, Optional

def apiV1MonitoringPolymarketStatus() -> Dict[str, Any]:
    """
    Get Polymarket Status
    
    
    Returns:
        API response as dictionary
    
    Raises:
        requests.exceptions.RequestException: If the request fails
    """
    try:
        url = 'https://api.spmc.dev/api/v1/monitoring/polymarket/status'
        headers = {
            "Content-Type": "application/json"
    }
        response = requests.get(url, headers=headers)
        response.raise_for_status()
        return response.json()
    except requests.exceptions.RequestException as e:
        print(f'Error calling /api/v1/monitoring/polymarket/status: {e}')
        raise

async function apiV1MonitoringPolymarketSubscription-analysis() {
  try {
    const response = await fetch('https://api.spmc.dev/api/v1/monitoring/polymarket/subscription-analysis', {
    method: 'GET',
    headers: {
      '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 calling /api/v1/monitoring/polymarket/subscription-analysis:', error);
    throw error;
  }
}

import requests
from typing import Dict, Any, Optional

def apiV1MonitoringPolymarketSubscription-analysis() -> Dict[str, Any]:
    """
    Analyze Polymarket Subscriptions
    
    
    Returns:
        API response as dictionary
    
    Raises:
        requests.exceptions.RequestException: If the request fails
    """
    try:
        url = 'https://api.spmc.dev/api/v1/monitoring/polymarket/subscription-analysis'
        headers = {
            "Content-Type": "application/json"
    }
        response = requests.get(url, headers=headers)
        response.raise_for_status()
        return response.json()
    except requests.exceptions.RequestException as e:
        print(f'Error calling /api/v1/monitoring/polymarket/subscription-analysis: {e}')
        raise