// Redirect user to authorization URL
const authUrl = `https://api.materi.dev/oauth/authorize?
  client_id=${CLIENT_ID}&
  response_type=code&
  scope=documents:read documents:write&
  redirect_uri=${CALLBACK_URL}`;

// Exchange authorization code for tokens
const response = await fetch("https://api.materi.dev/oauth/token", {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({
        grant_type: "authorization_code",
        client_id: CLIENT_ID,
        client_secret: CLIENT_SECRET,
        code: authorizationCode,
        redirect_uri: CALLBACK_URL,
    }),
});

const { access_token, refresh_token } = await response.json();

// For server-to-server integrations
const response = await fetch("https://api.materi.dev/oauth/token", {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({
        grant_type: "client_credentials",
        client_id: CLIENT_ID,
        client_secret: CLIENT_SECRET,
        scope: "documents:read workspaces:read",
    }),
});

const { access_token } = await response.json();

Authorization: Bearer eyJhbGciOiJSUzI1NiIsInR5cCI6IkpXVCJ9...

X-RateLimit-Limit: 1000
X-RateLimit-Remaining: 742
X-RateLimit-Reset: 1609459200
X-RateLimit-Retry-After: 3600

const rateLimitedApiCall = async (endpoint, options = {}) => {
    const response = await fetch(`https://api.materi.dev/v1${endpoint}`, {
        ...options,
        headers: {
            Authorization: `Bearer ${accessToken}`,
            "Content-Type": "application/json",
        },
    });

    if (response.status === 429) {
        const retryAfter = parseInt(response.headers.get("X-RateLimit-Retry-After"));
        console.warn(`Rate limit exceeded. Retry after ${retryAfter} seconds`);

        // Implement exponential backoff
        await new Promise((resolve) => setTimeout(resolve, retryAfter * 1000));
        return rateLimitedApiCall(endpoint, options);
    }

    return response.json();
};

{
    "error": {
        "code": "DOCUMENT_NOT_FOUND",
        "message": "The requested document could not be found",
        "details": {
            "document_id": "123e4567-e89b-12d3-a456-426614174000",
            "workspace_id": "workspace_abc123"
        },
        "request_id": "req_1234567890abcdef",
        "timestamp": "2025-01-15T10:30:00Z"
    }
}

class MateriAPI {
    constructor(accessToken) {
        this.baseURL = "https://api.materi.dev/v1";
        this.accessToken = accessToken;
    }

    async request(endpoint, options = {}) {
        const response = await fetch(`${this.baseURL}${endpoint}`, {
            ...options,
            headers: {
                Authorization: `Bearer ${this.accessToken}`,
                "Content-Type": "application/json",
                ...options.headers,
            },
        });

        if (!response.ok) {
            const error = await response.json();
            throw new Error(`API Error ${response.status}: ${error.error.message}`);
        }

        return response.json();
    }

    // Document operations
    async getDocuments(workspaceId = null) {
        const params = workspaceId ? `?workspace_id=${workspaceId}` : "";
        return this.request(`/documents${params}`);
    }

    async createDocument(data) {
        return this.request("/documents", {
            method: "POST",
            body: JSON.stringify(data),
        });
    }

    async getDocument(documentId) {
        return this.request(`/documents/${documentId}`);
    }

    async updateDocument(documentId, data) {
        return this.request(`/documents/${documentId}`, {
            method: "PATCH",
            body: JSON.stringify(data),
        });
    }

    // AI generation
    async generateContent(prompt, options = {}) {
        return this.request("/ai/generate", {
            method: "POST",
            body: JSON.stringify({ prompt, ...options }),
        });
    }
}

// Usage example
const api = new MateriAPI("your_access_token_here");

// Create a new document
const newDocument = await api.createDocument({
    title: "My API Document",
    content: "This document was created via the Materi API!",
    workspace_id: "workspace_123",
});

console.log("Created document:", newDocument.id);

// Generate AI content
const aiContent = await api.generateContent(
    "Write a summary of renewable energy benefits",
    { max_tokens: 500 }
);

console.log("Generated content:", aiContent.content);

npm install @materi/api-client

import { MateriAPI } from "@materi/api-client";

const client = new MateriAPI({
    accessToken: "your_token",
    environment: "production",
});

const documents = await client.documents.list();

pip install materi-python

from materi import MateriClient

client = MateriClient(access_token='your_token')
documents = client.documents.list()

go get github.com/materi/materi-go

import "github.com/materi/materi-go"

client := materi.NewClient("your_token")
documents, err := client.Documents.List(ctx)