# With shell, you can just pass the correct header with each request
curl "api_endpoint_here" \
  -H "Authorization: Bearer API_KEY"

  await fetch(url, {
    method: 'GET',
    headers: {
      'Authorization': `Bearer ${API_KEY}`,
    },
  });

  await fetch(url, {
    method: 'GET',
    headers: {
      'Authorization': `Bearer ${API_KEY}`,
    },
  });

        $ch = curl_init($url);

        curl_setopt_array($ch, [
            CURLOPT_HTTPHEADER => [
                'Content-Type: application/json',
                'Authorization: Bearer ' . $apiKey
            ],
        ]);

#!/bin/bash

URL="https://api.instapage.com/v1/workspaces"
TOKEN="your_api_token"
MAX_RETRIES=5
INITIAL_DELAY=1  # Initial delay in seconds

retry_count=0
delay=$INITIAL_DELAY

while [ $retry_count -lt $MAX_RETRIES ]; do
    response=$(curl -s -o response.txt -w "%{http_code}" -H "Authorization: Bearer $TOKEN" "$URL")

    if [ "$response" -ne 429 ]; then
        cat response.txt  # Output the response if it's not a rate limit error
        exit 0
    fi

    echo "Rate limit exceeded. Retrying in $delay seconds..."
    sleep $delay

    # Exponential backoff (double the delay each time)
    delay=$((delay * 2))
    retry_count=$((retry_count + 1))
done

echo "Max retries reached. Exiting."
exit 1

class RateLimiter {
    constructor(maxRequests, intervalMs) {
        this.maxRequests = maxRequests;
        this.intervalMs = intervalMs;
        this.requestTimestamps = [];
    }

    async schedule() {
        const now = Date.now();
        this.requestTimestamps = this.requestTimestamps.filter(ts => ts > now - this.intervalMs);

        if (this.requestTimestamps.length >= this.maxRequests) {
            const waitTime = this.requestTimestamps[0] + this.intervalMs - now;
            console.warn(`Rate limit approaching. Waiting ${waitTime}ms before next request.`);
            await new Promise(resolve => setTimeout(resolve, waitTime));
        }

        this.requestTimestamps.push(Date.now());
    }
}

function wrapFunctionWithRateLimit(fn, rateLimiter) {
    return async function (...args) {
        await rateLimiter.schedule();
        return fn(...args);
    };
}

function wrapFunctionWithRetries(fn, retries = 5, initialDelay = 1000) {
    return async function (...args) {
        let attempt = 0;
        let delay = initialDelay;

        while (attempt <= retries) {
            const response = await fn(...args);  // Call the wrapped function

            if (response.status === 429) {
                const backoff = delay * (2 ** attempt);  // Exponential backoff
                console.warn(`Rate limit exceeded. Retrying in ${backoff / 1000} seconds...`);
                await new Promise(resolve => setTimeout(resolve, backoff));
                attempt++;
            } else {
                return response;  // Return the full response if it's not a 429
            }
        }

        throw new Error("Max retries reached. Request failed.");
    };
}

async function fetchWorkspaces(page, apiKey) {
    const url = `https://api.instapage.com/v1/workspaces?page=${page}`;

    const response = await fetch(url, {
        headers: { 'Authorization': `Bearer ${apiKey}` },
    });

    if (!response.ok) {
        throw new Error(`Failed to fetch workspaces: ${response.statusText}`);
    }

    return response;  // Return the whole response object
}


// Usage example
// Create rate limiter instance (200 requests per minute)
const rateLimiter = new RateLimiter(200, 60000);

// Wrap the function with both rate limiting and retry logic
const fetchWorkspacesGracefully = wrapFunctionWithRateLimit(
    wrapFunctionWithRetries(fetchWorkspaces, 5, 1000),
    rateLimiter
);

fetchWorkspacesGracefully(1, 'API_KEY');

type Workspace = {
    workspaceId: number;
    ownerId: number;
    workspaceName: string;
    accessLevel: 'owner' | 'editor' | 'manager' | 'viewer';
    createdAt: number;
};

type Meta = {
    page: number;
};

type WorkspacesResponse = {
    data: Workspace[];
    meta: Meta;
};

class RateLimiter {
    private maxRequests: number;
    private intervalMs: number;
    private requestTimestamps: number[];

    constructor(maxRequests: number, intervalMs: number) {
        this.maxRequests = maxRequests;
        this.intervalMs = intervalMs;
        this.requestTimestamps = [];
    }

    async schedule(): Promise<void> {
        const now = Date.now();
        this.requestTimestamps = this.requestTimestamps.filter(ts => ts > now - this.intervalMs);

        if (this.requestTimestamps.length >= this.maxRequests) {
            const waitTime = this.requestTimestamps[0] + this.intervalMs - now;
            console.warn(`Rate limit approaching. Waiting ${waitTime}ms before next request.`);
            await new Promise(resolve => setTimeout(resolve, waitTime));
        }

        this.requestTimestamps.push(Date.now());
    }
}

function wrapFunctionWithRateLimit<T extends Function>(fn: T, rateLimiter: RateLimiter): T {
    return async function (...args: any[]) {
        await rateLimiter.schedule();
        return fn(...args);
    } as T;
}

function wrapFunctionWithRetries<T extends Function>(
    fn: T,
    retries = 5,
    initialDelay = 1000
): T {
    return async function (...args: any[]) {
        let attempt = 0;
        let delay = initialDelay;

        while (attempt <= retries) {
            const response = await fn(...args);

            if (response.status === 429) {
                const backoff = delay * (2 ** attempt);
                console.warn(`Rate limit exceeded. Retrying in ${backoff / 1000} seconds...`);
                await new Promise(resolve => setTimeout(resolve, backoff));
                attempt++;
            } else {
                return response; // Return the full response if it's not a 429
            }
        }

        throw new Error("Max retries reached. Request failed.");
    } as T;
}

async function fetchWorkspaces(page: number, apiKey: string): Promise<WorkspacesResponse> {
    const url = `https://api.instapage.com/v1/workspaces?page=${page}`;

    const response = await fetch(url, {
        headers: { 'Authorization': `Bearer ${apiKey}` },
    });

    if (!response.ok) {
        throw new Error(`Failed to fetch workspaces: ${response.statusText}`);
    }

    const data: WorkspacesResponse = await response.json();
    return data;
}

// Usage example
// Create a rate limiter instance (200 requests per minute)
const rateLimiter = new RateLimiter(200, 60000);

// Wrap the function with both rate limiting and retry logic
const fetchWorkspacesGracefully = wrapFunctionWithRateLimit(
    wrapFunctionWithRetries(fetchWorkspaces, 5, 1000),
    rateLimiter
);

fetchWorkspacesGracefully(1, 'API_KEY')
    .then(data => {
        console.log('Fetched workspaces:', data);
    })
    .catch(error => {
        console.error('Error fetching workspaces:', error);
    });

<?php

declare(strict_types=1);

namespace InstapageWorkspacesFetcher;

enum AccessLevel: string
{
    case Owner = 'owner';
    case Editor = 'editor';
    case Manager = 'manager';
    case Viewer = 'viewer';
}

readonly class Workspace
{
    public function __construct(
        public int $workspaceId,
        public int $ownerId,
        public string $workspaceName,
        public AccessLevel $accessLevel,
        public int $createdAt
    ) {}

    public function toArray(): array
    {
        return [
            'workspaceId' => $this->workspaceId,
            'ownerId' => $this->ownerId,
            'workspaceName' => $this->workspaceName,
            'accessLevel' => $this->accessLevel->value,
            'createdAt' => $this->createdAt
        ];
    }

    public static function fromArray(array $data): self
    {
        return new self(
            $data['workspaceId'],
            $data['ownerId'],
            $data['workspaceName'],
            AccessLevel::from($data['accessLevel']),
            $data['createdAt']
        );
    }
}

readonly class Meta
{
    public function __construct(
        public int $page
    ) {}

    public function toArray(): array
    {
        return [
            'page' => $this->page
        ];
    }

    public static function fromArray(array $data): self
    {
        return new self($data['page']);
    }
}

class WorkspacesResponse
{
    /**
     * @param Workspace[] $data
     */
    public function __construct(
        private array $data,
        private Meta $meta
    ) {}

    /**
     * @return Workspace[]
     */
    public function getData(): array
    {
        return $this->data;
    }

    public function getMeta(): Meta
    {
        return $this->meta;
    }
}

class RateLimiter
{
    private int $maxRequests;
    private int $intervalMs;
    private array $requestTimestamps;

    public function __construct(int $maxRequests, int $intervalMs)
    {
        $this->maxRequests = $maxRequests;
        $this->intervalMs = $intervalMs;
        $this->requestTimestamps = [];
    }

    public function schedule(): void
    {
        $now = (int) (microtime(true) * 1000);
        $this->requestTimestamps = array_filter(
            $this->requestTimestamps,
            fn($timestamp) => $timestamp > $now - $this->intervalMs
        );

        if (count($this->requestTimestamps) >= $this->maxRequests) {
            $waitTime = $this->requestTimestamps[0] + $this->intervalMs - $now;
            echo "Rate limit approaching. Waiting {$waitTime}ms before next request.\n";
            usleep($waitTime * 1000); // Sleep in microseconds
        }

        $this->requestTimestamps[] = (int) (microtime(true) * 1000);
    }
}

class WorkspacesFetcher
{
    public function __construct(
        private string $baseUrl,
        private string $apiKey,
        private RateLimiter $rateLimiter // Pass rateLimiter as parameter
    ) {}

    public function fetchWorkspaces(int $page, int $retries = 5, int $initialDelay = 1000): WorkspacesResponse
    {
        $url = sprintf(
            '%s/v1/workspaces?page=%d',
            $this->baseUrl,
            $page
        );

        $attempt = 0;
        $delay = $initialDelay;

        while ($attempt <= $retries) {
            $this->rateLimiter->schedule(); // Ensure rate limiting is respected

            $ch = curl_init($url);
            curl_setopt_array($ch, [
                CURLOPT_RETURNTRANSFER => true,
                CURLOPT_HTTPHEADER => [
                    'Authorization: Bearer ' . $this->apiKey,
                    'Content-Type: application/json'
                ]
            ]);

            $responseBody = curl_exec($ch);
            $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);

            if (curl_errno($ch)) {
                throw new \RuntimeException('CURL Error: ' . curl_error($ch));
            }

            curl_close($ch);

            if ($httpCode === 200) {
                $responseData = json_decode($responseBody, true);
                return new WorkspacesResponse(
                    array_map(
                        fn($workspaceData) => Workspace::fromArray($workspaceData),
                        $responseData['data']
                    ),
                    Meta::fromArray($responseData['meta'])
                );
            }

            if ($httpCode === 429) {
                $backoff = $delay * (2 ** $attempt); // Exponential backoff
                echo "Rate limit exceeded. Retrying in {$backoff / 1000} seconds...\n";
                usleep($backoff * 1000); // Sleep in microseconds
                $attempt++;
            } else {
                throw new \RuntimeException("Failed to fetch workspaces: HTTP $httpCode");
            }
        }

        throw new \RuntimeException("Max retries reached. Request failed.");
    }
}

// Example usage
try {
    $baseUrl = 'https://api.instapage.com';
    $apiKey = 'your_api_key_here';
    $page = 1;
    $rateLimiter = new RateLimiter(200, 60000); // Create a rate limiter instance

    $fetcher = new WorkspacesFetcher($baseUrl, $apiKey, $rateLimiter); // Pass it to the fetcher
    $workspacesResponse = $fetcher->fetchWorkspaces($page);

    // Process workspaces
    foreach ($workspacesResponse->getData() as $workspace) {
        print_r($workspace->toArray());
    }

    // Access metadata
    $meta = $workspacesResponse->getMeta();
    print_r($meta->toArray());

} catch (\Exception $e) {
    echo 'Error: ' . $e->getMessage();
}

curl "https://api.instapage.com/v1/workspaces?page=1" \
  -H "Authorization: Bearer API_KEY"

async function fetchWorkspaces(page, apiKey) {
    const response = await fetch(`https://api.instapage.com/v1/workspaces?page=${page}`, {
        headers: {
            'Authorization': `Bearer ${apiKey}`,
        },
    });

    if (!response.ok) {
        throw new Error(`Failed to fetch workspaces: ${response.statusText}`);
    }

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

type Workspace = {
    workspaceId: number;
    ownerId: number;
    workspaceName: string;
    accessLevel: 'owner' | 'editor' | 'manager' | 'viewer';
    createdAt: number;
};

type Meta = {
    page: number;
};

type WorkspacesResponse = {
    data: Workspace[];
    meta: Meta;
};

async function fetchWorkspaces(page: number, apiKey: string): Promise<WorkspacesResponse> {
    const response = await fetch(`https://api.instapage.com/v1/workspaces?page=${page}`, {
        headers: {
            'Authorization': `Bearer ${apiKey}`,
        },
    });

    if (!response.ok) {
        throw new Error(`Failed to fetch workspaces: ${response.statusText}`);
    }

    const data: WorkspacesResponse = await response.json();
    return data;
}

<?php

declare(strict_types=1);

namespace InstapageWorkspacesFetcher;

enum AccessLevel: string
{
    case Owner = 'owner';
    case Editor = 'editor';
    case Manager = 'manager';
    case Viewer = 'viewer';
}

readonly class Workspace
{
    public function __construct(
        public int $workspaceId,
        public int $ownerId,
        public string $workspaceName,
        public AccessLevel $accessLevel,
        public int $createdAt
    ) {}

    public function toArray(): array
    {
        return [
            'workspaceId' => $this->workspaceId,
            'ownerId' => $this->ownerId,
            'workspaceName' => $this->workspaceName,
            'accessLevel' => $this->accessLevel->value,
            'createdAt' => $this->createdAt
        ];
    }

    public static function fromArray(array $data): self
    {
        return new self(
            $data['workspaceId'],
            $data['ownerId'],
            $data['workspaceName'],
            AccessLevel::from($data['accessLevel']),
            $data['createdAt']
        );
    }
}

readonly class Meta
{
    public function __construct(
        public int $page
    ) {}

    public function toArray(): array
    {
        return [
            'page' => $this->page
        ];
    }

    public static function fromArray(array $data): self
    {
        return new self($data['page']);
    }
}

class WorkspacesResponse
{
    /**
     * @param Workspace[] $data
     */
    public function __construct(
        private array $data,
        private Meta $meta
    ) {}

    /**
     * @return Workspace[]
     */
    public function getData(): array
    {
        return $this->data;
    }

    public function getMeta(): Meta
    {
        return $this->meta;
    }
}

class WorkspacesFetcher
{
    public function __construct(
        private string $baseUrl,
        private string $apiKey
    ) {}

    public function fetchWorkspaces(int $page): WorkspacesResponse
    {
        $url = sprintf(
            '%s/v1/workspaces?page=%d',
            $this->baseUrl,
            $page
        );

        $ch = curl_init($url);

        curl_setopt_array($ch, [
            CURLOPT_RETURNTRANSFER => true,
            CURLOPT_HTTPHEADER => [
                'Authorization: Bearer ' . $this->apiKey,
                'Content-Type: application/json'
            ]
        ]);

        $responseBody = curl_exec($ch);
        $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);

        if (curl_errno($ch)) {
            throw new \RuntimeException('CURL Error: ' . curl_error($ch));
        }

        curl_close($ch);

        if ($httpCode !== 200) {
            throw new \RuntimeException("Failed to fetch workspaces: HTTP $httpCode");
        }

        $responseData = json_decode($responseBody, true);

        return new WorkspacesResponse(
            array_map(
                fn($workspaceData) => Workspace::fromArray($workspaceData),
                $responseData['data']
            ),
            Meta::fromArray($responseData['meta'])
        );
    }
}

// Example usage
try {
    $baseUrl = 'https://api.instapage.com';
    $apiKey = 'your_api_key_here';
    $page = 1;

    $fetcher = new WorkspacesFetcher($baseUrl, $apiKey);

    $workspacesResponse = $fetcher->fetchWorkspaces($page);

    // Process workspaces
    foreach ($workspacesResponse->getData() as $workspace) {
        // Do something with each workspace
        print_r($workspace->toArray());
    }

    // Access metadata
    $meta = $workspacesResponse->getMeta();
    print_r($meta->toArray());

} catch (\Exception $e) {
    echo 'Error: ' . $e->getMessage();
}

{
  "data": [
    {
      "workspaceId": 1177,
      "ownerId": 1319,
      "workspaceName": "Personal Projects",
      "accessLevel": "owner",
      "createdAt": 1262304000
    },
    {
      "workspaceId": 1801,
      "ownerId": 1637,
      "workspaceName": "Personal Projects",
      "accessLevel": "viewer",
      "createdAt": 1262304000
    },
    {
      "workspaceId": 2637,
      "ownerId": 2517,
      "workspaceName": "Personal Projects",
      "accessLevel": "manager",
      "createdAt": 1262304000
    },
    {
      "workspaceId": 1771,
      "ownerId": 1624,
      "workspaceName": "Personal Projects",
      "accessLevel": "editor",
      "createdAt": 1262304000
    }
  ],
  "meta": {
    "pagination": {
      "currentPage": 1,
      "perPage": 100,
      "totalItemsCount": 4,
      "totalPagesCount": 1,
      "nextPage": null,
      "previousPage": null
    }
  }
}

curl -X GET "https://api.instapage.com/v1/workspaces/{workspaceId}" \
  -H "Authorization: Bearer API_KEY" \
  -H "Content-Type: application/json"

async function getWorkspace(workspaceId, apiKey) {
    const response = await fetch(`https://api.instapage.com/v1/workspaces/${workspaceId}`, {
        method: 'GET',
        headers: {
            'Authorization': `Bearer ${apiKey}`,
            'Content-Type': 'application/json',
        },
    });

    if (!response.ok) {
        throw new Error(`Failed to get workspace: ${response.statusText}`);
    }

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

// Example usage
const apiKey = 'your_api_key_here';
const workspaceId = 12345;

getWorkspace(workspaceId. apiKey)
  .then(workspace => {
    console.log('Workspace:', workspace);
  })
  .catch(error => {
    console.error('Error getting workspace:', error);
  });

type AccessLevel = 'owner' | 'editor' | 'manager' | 'viewer';

interface Workspace {
    workspaceId: number;
    ownerId: number;
    workspaceName: string;
    accessLevel: AccessLevel;
    createdAt: number;
}

class WorkspaceFetcher {
    private baseUrl: string;
    private apiKey: string;

    constructor(baseUrl: string, apiKey: string) {
        this.baseUrl = baseUrl;
        this.apiKey = apiKey;
    }

    async getWorkspace(workspaceId: number): Promise<Workspace> {
        const url = `${this.baseUrl}/v1/workspaces/${workspaceId}`;

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

        if (!response.ok) {
          throw new Error(`Failed to get workspace: ${response.statusText}`);
        }

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

// Example usage
const baseUrl = 'https://api.instapage.com';
const apiKey = 'your_api_key_here';
const fetcher = new WorkspaceFetcher(baseUrl, apiKey);
const workspaceId = 12345;

fetcher.getWorkspace(workspaceId)
    .then(workspace => {
        console.log('Workspace:', workspace);
    })
    .catch(error => {
        console.error('Error getting workspace:', error);
    });

<?php

declare(strict_types=1);

namespace InstapageWorkspacesFetcher;

enum AccessLevel: string
{
    case Owner = 'owner';
    case Editor = 'editor';
    case Manager = 'manager';
    case Viewer = 'viewer';
}

readonly class Workspace
{
    public function __construct(
        public int $workspaceId,
        public int $ownerId,
        public string $workspaceName,
        public AccessLevel $accessLevel,
        public int $createdAt
    ) {}

    public static function fromArray(array $data): self
    {
        return new self(
            $data['workspaceId'],
            $data['ownerId'],
            $data['workspaceName'],
            AccessLevel::from($data['accessLevel']),
            $data['createdAt']
        );
    }
}

class WorkspacesFetcher
{
    public function __construct(
        private string $baseUrl,
        private string $apiKey
    ) {}

    public function getWorkspace(int $workspaceId): Workspace
    {
        $url = sprintf('%s/v1/workspaces/%d', $this->baseUrl, $workspaceId);

        $ch = curl_init($url);

        curl_setopt_array($ch, [
            CURLOPT_RETURNTRANSFER => true,
            CURLOPT_HTTPHEADER => [
                'Authorization: Bearer ' . $this->apiKey,
                'Content-Type: application/json'
            ]
        ]);

        $responseBody = curl_exec($ch);
        $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);

        if (curl_errno($ch)) {
            throw new \RuntimeException('CURL Error: ' . curl_error($ch));
        }

        curl_close($ch);

        if ($httpCode !== 200) {
            throw new \RuntimeException("Failed to fetch workspace: HTTP $httpCode");
        }

        $responseData = json_decode($responseBody, true);

        return Workspace::fromArray($responseData['data']);
    }
}

// Example usage
try {
    $baseUrl = 'https://api.instapage.com';
    $apiKey = 'your_api_key_here';
    $workspaceId = 12345;

    $fetcher = new WorkspacesFetcher($baseUrl, $apiKey);

    $workspace = $fetcher->getWorkspace($workspaceId);

    echo 'Workspace retrieved: ' . json_encode($workspace, JSON_PRETTY_PRINT);
} catch (\Exception $e) {
    echo 'Error: ' . $e->getMessage();
}

{
  "data": {
      "workspaceId": 2000,
      "ownerId": 1319,
      "workspaceName": "New Workspace Name",
      "accessLevel": "owner",
      "createdAt": 1700304000
  }
}

curl -X POST "https://api.instapage.com/v1/workspaces" \
  -H "Authorization: Bearer API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"name": "New Workspace"}'

async function createWorkspace(name, apiKey) {
    const response = await fetch(`https://api.instapage.com/v1/workspaces`, {
        method: 'POST',
        headers: {
            'Authorization': `Bearer ${apiKey}`,
            'Content-Type': 'application/json',
        },
        body: JSON.stringify({ name }),
    });

    if (!response.ok) {
        throw new Error(`Failed to create workspace: ${response.statusText}`);
    }

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

type AccessLevel = 'owner' | 'editor' | 'manager' | 'viewer';

interface Workspace {
    workspaceId: number;
    ownerId: number;
    workspaceName: string;
    accessLevel: AccessLevel;
    createdAt: number;
}

class WorkspaceCreator {
    private baseUrl: string;
    private apiKey: string;

    constructor(baseUrl: string, apiKey: string) {
        this.baseUrl = baseUrl;
        this.apiKey = apiKey;
    }

    async createWorkspace(name: string): Promise<Workspace> {
        const url = `${this.baseUrl}/v1/workspaces`;

        const payload = JSON.stringify({ name });
        const response = await fetch(url, {
            method: 'POST',
            headers: {
                'Authorization': `Bearer ${this.apiKey}`,
                'Content-Type': 'application/json',
                'Content-Length': payload.length.toString(),
            },
            body: payload,
        });

        if (!response.ok) {
            throw new Error(`Failed to create workspace: ${response.statusText}`);
        }

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

// Example usage
const baseUrl = 'https://api.instapage.com';
const apiKey = 'your_api_key_here';
const creator = new WorkspaceCreator(baseUrl, apiKey);

creator.createWorkspace('New Workspace Name')
    .then(workspace => {
        console.log('Created Workspace:', workspace);
    })
    .catch(error => {
        console.error('Error creating workspace:', error);
    });

<?php

declare(strict_types=1);

namespace InstapageWorkspacesCreator;

enum AccessLevel: string
{
    case Owner = 'owner';
    case Editor = 'editor';
    case Manager = 'manager';
    case Viewer = 'viewer';
}

readonly class Workspace
{
    public function __construct(
        public int $workspaceId,
        public int $ownerId,
        public string $workspaceName,
        public AccessLevel $accessLevel,
        public int $createdAt
    ) {}

    public static function fromArray(array $data): self
    {
        return new self(
            $data['workspaceId'],
            $data['ownerId'],
            $data['workspaceName'],
            AccessLevel::from($data['accessLevel']),
            $data['createdAt']
        );
    }
}

class WorkspacesCreator
{
    public function __construct(
        private string $baseUrl,
        private string $apiKey
    ) {}

    public function createWorkspace(string $name): WorkspacesResponse
    {
        $url = sprintf(
            '%s/v1/workspaces',
            $this->baseUrl,
            $page
        );

        $ch = curl_init($url);

        curl_setopt_array($ch, [
            CURLOPT_RETURNTRANSFER => true,
            CURLOPT_HTTPHEADER => [
                'Authorization: Bearer ' . $this->apiKey,
                'Content-Type: application/json'
            ]
        ]);

        $responseBody = curl_exec($ch);
        $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);

        if (curl_errno($ch)) {
            throw new \RuntimeException('CURL Error: ' . curl_error($ch));
        }

        curl_close($ch);

        if ($httpCode !== 200) {
            throw new \RuntimeException("Failed to fetch workspaces: HTTP $httpCode");
        }

        $responseData = json_decode($responseBody, true);

        return Workspace::fromArray($responseData['data']);
    }
}

// Example usage
try {
    $baseUrl = 'https://api.instapage.com';
    $apiKey = 'your_api_key_here';
    $newWorkspaceName = 'workspace-12';

    $creator = new WorkspacesCreator($baseUrl, $apiKey);

    $createResponse = $creator->createWorkspace($newWorkspaceName);
} catch (\Exception $e) {
    echo 'Error: ' . $e->getMessage();
}

{
  "data": {
      "workspaceId": 2000,
      "ownerId": 1319,
      "workspaceName": "New Workspace Name",
      "accessLevel": "owner",
      "createdAt": 1700304000
  }
}

curl -X PATCH "https://api.instapage.com/v1/workspaces/{workspaceId}" \
  -H "Authorization: Bearer API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"name": "New Workspace Name"}'

async function renameWorkspace(workspaceId, name, apiKey) {
    const response = await fetch(`https://api.instapage.com/v1/workspaces/${workspaceId}`, {
        method: 'PATCH',
        headers: {
            'Authorization': `Bearer ${apiKey}`,
            'Content-Type': 'application/json',
        },
        body: JSON.stringify({ name }),
    });

    if (!response.ok) {
        throw new Error(`Failed to rename workspace: ${response.statusText}`);
    }

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


// Example usage
const workspaceId = 123;
const newWorkspaceName = 'Renamed Workspace';
const apiKey = 'your_api_key_here';

renameWorkspace(workspaceId, newWorkspaceName, apiKey)
    .then(data => {
        console.log('Renamed Workspace:', data);
    })
    .catch(error => {
        console.error('Error renaming workspace:', error);
    });

type AccessLevel = 'owner' | 'editor' | 'manager' | 'viewer';

interface Workspace {
    workspaceId: number;
    ownerId: number;
    workspaceName: string;
    accessLevel: AccessLevel;
    createdAt: number;
}

class WorkspaceRenamer {
    private baseUrl: string;
    private apiKey: string;

    constructor(baseUrl: string, apiKey: string) {
        this.baseUrl = baseUrl;
        this.apiKey = apiKey;
    }

    async renameWorkspace(workspaceId: number, newName: string): Promise<Workspace> {
        const url = `${this.baseUrl}/v1/workspaces/${workspaceId}`;

        const payload = JSON.stringify({ name: newName });
        const response = await fetch(url, {
            method: 'PATCH',
            headers: {
                'Authorization': `Bearer ${this.apiKey}`,
                'Content-Type': 'application/json',
                'Content-Length': payload.length.toString(),
            },
            body: payload,
        });

        if (!response.ok) {
            throw new Error(`Failed to rename workspace: ${response.statusText}`);
        }

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

// Example usage
const baseUrl = 'https://api.instapage.com';
const apiKey = 'your_api_key_here';
const renamer = new WorkspaceRenamer(baseUrl, apiKey);

const workspaceId = 123;
const newWorkspaceName = 'Renamed Workspace';

renamer.renameWorkspace(workspaceId, newWorkspaceName)
    .then(workspace => {
        console.log('Renamed Workspace:', workspace);
    })
    .catch(error => {
        console.error('Error renaming workspace:', error);
    });

<?php

declare(strict_types=1);

namespace InstapageWorkspacesRenamer;

enum AccessLevel: string
{
    case Owner = 'owner';
    case Editor = 'editor';
    case Manager = 'manager';
    case Viewer = 'viewer';
}

readonly class Workspace
{
    public function __construct(
        public int $workspaceId,
        public int $ownerId,
        public string $workspaceName,
        public AccessLevel $accessLevel,
        public int $createdAt
    ) {}

    public static function fromArray(array $data): self
    {
        return new self(
            $data['workspaceId'],
            $data['ownerId'],
            $data['workspaceName'],
            AccessLevel::from($data['accessLevel']),
            $data['createdAt']
        );
    }
}

class WorkspacesRenamer
{
    public function __construct(
        private string $baseUrl,
        private string $apiKey
    ) {}

    public function renameWorkspace(int $workspaceId, string $newName): Workspace
    {
        $url = sprintf('%s/v1/workspaces/%d', $this->baseUrl, $workspaceId);

        $payload = json_encode(['name' => $newName]);

        $ch = curl_init($url);
        curl_setopt_array($ch, [
            CURLOPT_RETURNTRANSFER => true,
            CURLOPT_HTTPHEADER => [
                'Authorization: Bearer ' . $this->apiKey,
                'Content-Type: application/json',
            ],
            CURLOPT_CUSTOMREQUEST => 'PATCH',
            CURLOPT_POSTFIELDS => $payload,
        ]);

        $responseBody = curl_exec($ch);
        $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);

        if (curl_errno($ch)) {
            throw new \RuntimeException('CURL Error: ' . curl_error($ch));
        }

        curl_close($ch);

        if ($httpCode !== 200) {
            throw new \RuntimeException("Failed to rename workspace: HTTP $httpCode");
        }

        $responseData = json_decode($responseBody, true);

        return Workspace::fromArray($responseData['data']);
    }
}

// Example usage
try {
    $baseUrl = 'https://api.instapage.com';
    $apiKey = 'your_api_key_here';
    $workspaceId = 123;
    $newWorkspaceName = 'Renamed Workspace';

    $renamer = new WorkspacesRenamer($baseUrl, $apiKey);

    $updatedWorkspace = $renamer->renameWorkspace($workspaceId, $newWorkspaceName);
    echo 'Workspace renamed to: ' . $updatedWorkspace->workspaceName;
} catch (\Exception $e) {
    echo 'Error: ' . $e->getMessage();
}

{
  "data": {
      "workspaceId": 2000,
      "ownerId": 1319,
      "workspaceName": "New Workspace Name",
      "accessLevel": "owner",
      "createdAt": 1700304000
  }
}

curl -X DELETE "https://api.instapage.com/v1/workspaces/{workspaceId}" \
  -H "Authorization: Bearer API_KEY" \
  -H "Content-Type: application/json"

async function deleteWorkspace(workspaceId, apiKey) {
    const response = await fetch(`https://api.instapage.com/v1/workspaces/${workspaceId}`, {
        method: 'DELETE',
        headers: {
            'Authorization': `Bearer ${apiKey}`,
            'Content-Type': 'application/json',
        },
    });

    if (!response.ok) {
        throw new Error(`Failed to delete workspace: ${response.statusText}`);
    }

    return response.json();
}

// Example usage
const workspaceId = 'workspaceId_here';
const apiKey = 'your_api_key_here';

deleteWorkspace(workspaceId, apiKey)
    .then(data => {
        console.log('Workspace deleted:', data);
    })
    .catch(error => {
        console.error('Error deleting workspace:', error);
    });

class WorkspaceDeleter {
    private baseUrl: string;
    private apiKey: string;

    constructor(baseUrl: string, apiKey: string) {
        this.baseUrl = baseUrl;
        this.apiKey = apiKey;
    }

    async deleteWorkspace(workspaceId: string): Promise<void> {
        const url = `${this.baseUrl}/v1/workspaces/${workspaceId}`;

        const response = await fetch(url, {
            method: 'DELETE',
            headers: {
                'Authorization': `Bearer ${this.apiKey}`,
                'Content-Type': 'application/json',
            },
        });

        if (!response.ok) {
            throw new Error(`Failed to delete workspace: ${response.statusText}`);
        }

        console.log('Workspace deleted successfully');
    }
}

// Example usage
const baseUrl = 'https://api.instapage.com';
const apiKey = 'your_api_key_here';
const deleter = new WorkspaceDeleter(baseUrl, apiKey);

deleter.deleteWorkspace('workspaceId_here')
    .then(() => {
        console.log('Workspace deleted');
    })
    .catch(error => {
        console.error('Error deleting workspace:', error);
    });

<?php

declare(strict_types=1);

namespace Instapage\PublicApi\UserInterface\Workspaces;

class WorkspaceDeleter
{
    public function __construct(
        private string $baseUrl,
        private string $apiKey
    ) {}

    public function deleteWorkspace(string $workspaceId): void
    {
        $url = sprintf(
            '%s/v1/workspaces/%s',
            $this->baseUrl,
            $workspaceId
        );

        $ch = curl_init($url);

        curl_setopt_array($ch, [
            CURLOPT_RETURNTRANSFER => true,
            CURLOPT_HTTPHEADER => [
                'Authorization: Bearer ' . $this->apiKey,
                'Content-Type: application/json'
            ],
            CURLOPT_CUSTOMREQUEST => 'DELETE'
        ]);

        $responseBody = curl_exec($ch);
        $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);

        if (curl_errno($ch)) {
            throw new \RuntimeException('CURL Error: ' . curl_error($ch));
        }

        curl_close($ch);

        if ($httpCode !== 200) {
            throw new \RuntimeException("Failed to delete workspace: HTTP $httpCode");
        }
    }
}

// Example usage
try {
    $baseUrl = 'https://api.instapage.com';
    $apiKey = 'your_api_key_here';
    $workspaceId = 'workspaceId_here';

    $deleter = new WorkspaceDeleter($baseUrl, $apiKey);

    $deleter->deleteWorkspace($workspaceId);
} catch (\Exception $e) {
    echo 'Error: ' . $e->getMessage();
}

curl "https://api.instapage.com/v1/workspaces/{workspaceId}/team-members" \
  -H "Authorization: Bearer TOKEN" \
  -H "Content-Type: application/json"

{
  "data": [
    {
      "userId": 4379,
      "email": "example_user@airslate.com",
      "invitedAt": 1685608225,
      "fullName": "John Smith",
      "accessLevel": "editor",
      "invitationStatus": "accepted",
      "lastLoginAt": 1685608226,
      "lastActivityInWorkspaceAt": null
    },
    {
      "userId": 4377,
      "email": "example1_user@airslate.com",
      "invitedAt": 1684489737,
      "fullName": "John Smith",
      "accessLevel": "manager",
      "invitationStatus": "accepted",
      "lastLoginAt": 1685970113,
      "lastActivityInWorkspaceAt": null
    },
    {
      "userId": 4373,
      "email": "example1_user@airslate.com",
      "invitedAt": null,
      "fullName": "John Smith",
      "accessLevel": "owner",
      "invitationStatus": "accepted",
      "lastLoginAt": 1729173925,
      "lastActivityInWorkspaceAt": 1729520831
    }
  ],
  "meta": []
}

async function fetchTeamMembers(workspaceId, apiKey) {
    const url = `https://api.instapage.com/v1/workspaces/${workspaceId}/team-members`;

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

    if (!response.ok) {
        throw new Error(`Failed to fetch team members: ${response.statusText}`);
    }

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

type TeamMember = {
    userId: number;
    email: string;
    invitedAt: number | null;
    fullName: string;
    accessLevel: string;
    invitationStatus: 'accepted' | 'pending';
    lastLoginAt: number | null;
    lastActivityInWorkspaceAt: number | null;
};

type TeamMembersResponse = {
    data: TeamMember[];
    meta: any;
};

async function fetchTeamMembers(
    workspaceId: number,
    apiKey: string
): Promise<TeamMembersResponse> {
    const url = `https://api.instapage.com/v1/workspaces/${workspaceId}/team-members`;

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

    if (!response.ok) {
        throw new Error(`Failed to fetch team members: ${response.statusText}`);
    }

    const data: TeamMembersResponse = await response.json();
    return data;
}

<?php

declare(strict_types=1);

namespace InstapageTeamMembersFetcher;

enum InvitationStatus: string
{
    case Accepted = 'accepted';
    case Pending = 'pending';
}

readonly class TeamMember
{
    public function __construct(
        public int $userId,
        public string $email,
        public ?int $invitedAt,
        public string $fullName,
        public string $accessLevel,
        public InvitationStatus $invitationStatus,
        public ?int $lastLoginAt,
        public ?int $lastActivityInWorkspaceAt
    ) {}

    public function toArray(): array
    {
        return [
            'userId' => $this->userId,
            'email' => $this->email,
            'invitedAt' => $this->invitedAt,
            'fullName' => $this->fullName,
            'accessLevel' => $this->accessLevel,
            'invitationStatus' => $this->invitationStatus->value,
            'lastLoginAt' => $this->lastLoginAt,
            'lastActivityInWorkspaceAt' => $this->lastActivityInWorkspaceAt
        ];
    }

    public static function fromArray(array $data): self
    {
        return new self(
            $data['userId'],
            $data['email'],
            $data['invitedAt'],
            $data['fullName'],
            $data['accessLevel'],
            InvitationStatus::from($data['invitationStatus']),
            $data['lastLoginAt'],
            $data['lastActivityInWorkspaceAt']
        );
    }
}

class TeamMembersResponse
{
    /**
     * @param TeamMember[] $data
     */
    public function __construct(
        private array $data,
        private array $meta
    ) {}

    /**
     * @return TeamMember[]
     */
    public function getData(): array
    {
        return $this->data;
    }

    public function getMeta(): array
    {
        return $this->meta;
    }
}

class TeamMembersFetcher
{
    public function __construct(
        private string $baseUrl,
        private string $apiKey
    ) {}

    public function fetchTeamMembers(int $workspaceId): TeamMembersResponse
    {
        $url = sprintf(
            '%s/v1/workspaces/%d/team-members',
            $this->baseUrl,
            $workspaceId
        );

        $ch = curl_init($url);

        curl_setopt_array($ch, [
            CURLOPT_RETURNTRANSFER => true,
            CURLOPT_HTTPHEADER => [
                'Authorization: Bearer ' . $this->apiKey,
                'Content-Type: application/json'
            ]
        ]);

        $responseBody = curl_exec($ch);
        $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);

        if (curl_errno($ch)) {
            throw new \RuntimeException('CURL Error: ' . curl_error($ch));
        }

        curl_close($ch);

        if ($httpCode !== 200) {
            throw new \RuntimeException("Failed to fetch team members: HTTP $httpCode");
        }

        $responseData = json_decode($responseBody, true);

        return new TeamMembersResponse(
            array_map(
                fn($memberData) => TeamMember::fromArray($memberData),
                $responseData['data']
            ),
            $responseData['meta']
        );
    }
}

// Example usage
try {
    $baseUrl = 'https://api.instapage.com';
    $apiKey = 'your_api_key_here';
    $workspaceId = 1234;

    $fetcher = new TeamMembersFetcher($baseUrl, $apiKey);

    $teamMembersResponse = $fetcher->fetchTeamMembers($workspaceId);

    // Process team members
    foreach ($teamMembersResponse->getData() as $teamMember) {
        // Do something with each team member
        print_r($teamMember->toArray());
    }

    // Access metadata if needed
    print_r($teamMembersResponse->getMeta());

} catch (\Exception $e) {
    echo 'Error: ' . $e->getMessage();
}

curl -X POST \
  https://api.instapage.com/v1/workspaces/{workspaceId}/team-members \
  -H 'Authorization: Bearer {token}' \
  -H 'Content-Type: application/json' \
  -d '[
    {
      "email": "user1@example.com",
      "accessLevel": "viewer"
    },
    {
      "email": "user2@example.com",
      "accessLevel": "manager"
    }
  ]'

async function inviteTeamMembers(workspaceId, teamMembers, apiKey) {
    const response = await fetch(
        `https://api.instapage.com/v1/workspaces/${workspaceId}/team-members`, 
        {
            method: 'POST',
            headers: {
                'Authorization': `Bearer ${apiKey}`,
                'Content-Type': 'application/json'
            },
            body: JSON.stringify(teamMembers)
        }
    );

    if (!response.ok) {
        const errorData = await response.json();
        throw new Error(`Failed to invite team members: ${errorData.details}`);
    }

    return response.json();
}

// Example usage
const teamMembers = [
    { email: "user1@example.com", accessLevel: "viewer" },
    { email: "user2@example.com", accessLevel: "manager" }
];

try {
    await inviteTeamMembers(workspaceId, teamMembers, apiKey);
    console.log('Team members invited successfully');
} catch (error) {
    console.error('Error inviting team members:', error);
}

type AccessLevel = 'viewer' | 'editor' | 'manager';

interface TeamMemberInvite {
    email: string;
    accessLevel: AccessLevel;
}

async function inviteTeamMembers(
    workspaceId: number,
    teamMembers: TeamMemberInvite[],
    apiKey: string
): Promise<void> {
    const response = await fetch(
        `https://api.instapage.com/v1/workspaces/${workspaceId}/team-members`,
        {
            method: 'POST',
            headers: {
                'Authorization': `Bearer ${apiKey}`,
                'Content-Type': 'application/json'
            },
            body: JSON.stringify(teamMembers)
        }
    );

    if (!response.ok) {
        const errorData = await response.json();
        throw new Error(`Failed to invite team members: ${errorData.details}`);
    }

    return response.json();
}

// Example usage
const teamMembers: TeamMemberInvite[] = [
    { email: "user1@example.com", accessLevel: "viewer" },
    { email: "user2@example.com", accessLevel: "manager" }
];

try {
    await inviteTeamMembers(workspaceId, teamMembers, apiKey);
    console.log('Team members invited successfully');
} catch (error) {
    console.error('Error inviting team members:', error);
}

<?php

declare(strict_types=1);

namespace InstapageTeamMembers;

enum AccessLevel: string {
    case Viewer = 'viewer';
    case Editor = 'editor';
    case Manager = 'manager';
}

readonly class TeamMemberInvite {
    public function __construct(
        public string $email,
        public AccessLevel $accessLevel
    ) {}

    public function toArray(): array {
        return [
            'email' => $this->email,
            'accessLevel' => $this->accessLevel->value
        ];
    }
}

class TeamMemberInviter {
    public function __construct(
        private string $baseUrl,
        private string $apiKey
    ) {}

    /**
     * @param TeamMemberInvite[] $teamMembers
     */
    public function inviteTeamMembers(
        int $workspaceId,
        array $teamMembers
    ): void {
        $url = sprintf(
            '%s/v1/workspaces/%d/team-members',
            $this->baseUrl,
            $workspaceId
        );

        $requestBody = array_map(
            fn($member) => $member->toArray(),
            $teamMembers
        );

        $ch = curl_init($url);
        curl_setopt_array($ch, [
            CURLOPT_RETURNTRANSFER => true,
            CURLOPT_POST => true,
            CURLOPT_HTTPHEADER => [
                'Authorization: Bearer ' . $this->apiKey,
                'Content-Type: application/json'
            ],
            CURLOPT_POSTFIELDS => json_encode($requestBody)
        ]);

        $response = curl_exec($ch);
        $statusCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
        curl_close($ch);

        if ($statusCode !== 201) {
            $errorData = json_decode($response, true);
            throw new \RuntimeException(
                "Failed to invite team members: " . 
                ($errorData['details'] ?? 'Unknown error')
            );
        }
    }
}

// Example usage
try {
    $inviter = new TeamMemberInviter(
        'https://api.instapage.com',
        'your_api_key_here'
    );

    $teamMembers = [
        new TeamMemberInvite('user1@example.com', AccessLevel::Viewer),
        new TeamMemberInvite('user2@example.com', AccessLevel::Manager)
    ];

    $inviter->inviteTeamMembers(123, $teamMembers);
    echo "Team members invited successfully\n";
} catch (\Exception $e) {
    echo 'Error: ' . $e->getMessage();
}