### POST /api/v3/payments/init

Source: https://context7.com/rabbicik/paybylink/llms.txt

Initializes a new payment transaction. This endpoint is used to start the payment process by providing payment details.

```APIDOC
## POST /api/v3/payments/init

### Description
Initializes a new payment transaction. This endpoint is used to start the payment process by providing payment details.

### Method
POST

### Endpoint
/api/v3/payments/init

### Parameters
#### Request Body
- **amount** (decimal) - Required - The payment amount.
- **currency** (string) - Optional - The currency of the payment (ISO 4217 format).
- **merchantId** (string) - Optional - The unique identifier for the merchant (UUID format).

### Request Example
```json
{
  "amount": 100.50,
  "currency": "EUR",
  "merchantId": "a1b2c3d4-e5f6-7890-1234-567890abcdef"
}
```

### Response
#### Success Response (200)
- **transactionId** (string) - The unique identifier for the transaction.
- **redirectUrl** (string) - The URL to redirect the user to complete the payment.
- **expiresAt** (datetime) - The expiration time of the payment link (ISO 8601 format).

#### Response Example
```json
{
  "transactionId": "txn_12345abcde",
  "redirectUrl": "https://pay.example.com/pay?token=xyz789",
  "expiresAt": "2023-10-27T10:00:00Z"
}
```
```

--------------------------------

### GET /api/v1/users

Source: https://context7.com/rabbicik/paybylink/llms.txt

Retrieves a list of users from the system.

```APIDOC
## GET /api/v1/users

### Description
Retrieves a list of users from the system.

### Method
GET

### Endpoint
/api/v1/users

### Parameters
#### Query Parameters
- **limit** (integer) - Optional - The maximum number of users to return.
- **offset** (integer) - Optional - The number of users to skip before starting to collect the result set.

#### Request Body
None

### Request Example
```
GET /api/v1/users?limit=10&offset=0 HTTP/1.1
Host: example.com
Authorization: Bearer YOUR_ACCESS_TOKEN
```

### Response
#### Success Response (200)
- **users** (array) - An array of user objects.
  - **user_id** (string) - The unique identifier for the user.
  - **username** (string) - The username of the user.
  - **email** (string) - The email address of the user.

#### Response Example
```json
{
  "users": [
    {
      "user_id": "user123",
      "username": "john_doe",
      "email": "john.doe@example.com"
    },
    {
      "user_id": "user456",
      "username": "jane_smith",
      "email": "jane.smith@example.com"
    }
  ]
}
```

#### Error Response (401)
- **error** (string) - Description of the error.

#### Error Response Example
```json
{
  "error": "Unauthorized: Invalid or expired token."
}
```
```

--------------------------------

### Extract API Endpoints from PDF using Regex

Source: https://context7.com/rabbicik/paybylink/llms.txt

This Python function extracts API endpoint details (method and URL) from PDF text using regular expressions. It specifically targets pages containing API documentation and uses regex patterns to identify common HTTP methods (POST, GET, PUT, DELETE) followed by API paths. The extracted information is structured into a list of dictionaries, each representing an endpoint with its method and URL. This aids in automatically generating API documentation or schemas.

```python
import re
import json
import pdfplumber

def extract_api_endpoints(pdf_path):
    """Extract API endpoints and parameters from payment documentation"""
    endpoints = []

    with pdfplumber.open(pdf_path) as pdf:
        # Focus on pages 3-5 which contain API documentation
        for page in pdf.pages[2:5]:
            text = page.extract_text()

            # Extract POST/GET/PUT endpoints
            endpoint_pattern = r'(POST|GET|PUT|DELETE)\s+(/api/v\d+/[^\s]+)'
            matches = re.findall(endpoint_pattern, text, re.MULTILINE)

            for method, path in matches:
                endpoint = {
                    "method": method,
                    "url": path,
                    "parameters": [],
                    "response": {}
                }
                endpoints.append(endpoint)

    return endpoints

# Extract and structure API information
api_schema = extract_api_endpoints("dokumentacja-przelewy.pdf")

# Example extracted schema
payment_init_endpoint = {
    "method": "POST",
    "url": "/api/v3/payments/init",
    "parameters": [
        {"name": "amount", "type": "decimal", "required": True},
        {"name": "currency", "type": "string", "format": "ISO 4217"},
        {"name": "merchantId", "type": "string", "format": "UUID"}
    ],
    "response": {
        "transactionId": "string",
        "redirectUrl": "string",
        "expiresAt": "datetime (ISO 8601)"
    }
}

print(json.dumps(payment_init_endpoint, indent=2))
```

--------------------------------

### GET /api/v3/payments/{transactionId}/status

Source: https://context7.com/rabbicik/paybylink/llms.txt

Retrieves the current status of a payment transaction. Use this endpoint to check if a payment has been completed, failed, or is pending.

```APIDOC
## GET /api/v3/payments/{transactionId}/status

### Description
Retrieves the current status of a payment transaction. Use this endpoint to check if a payment has been completed, failed, or is pending.

### Method
GET

### Endpoint
/api/v3/payments/{transactionId}/status

### Parameters
#### Path Parameters
- **transactionId** (string) - Required - The unique identifier for the transaction.

### Response
#### Success Response (200)
- **status** (string) - The current status of the transaction (e.g., "PENDING", "COMPLETED", "FAILED").

#### Response Example
```json
{
  "status": "COMPLETED"
}
```
```

--------------------------------

### POST /api/v1/users

Source: https://context7.com/rabbicik/paybylink/llms.txt

Creates a new user in the system.

```APIDOC
## POST /api/v1/users

### Description
Creates a new user in the system.

### Method
POST

### Endpoint
/api/v1/users

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **username** (string) - Required - The desired username for the new user.
- **email** (string) - Required - The email address for the new user.
- **password** (string) - Required - The password for the new user.

### Request Example
```json
{
  "username": "new_user",
  "email": "new.user@example.com",
  "password": "secure_password123"
}
```

### Response
#### Success Response (201)
- **user_id** (string) - The unique identifier for the newly created user.
- **username** (string) - The username of the newly created user.
- **email** (string) - The email address of the newly created user.

#### Response Example
```json
{
  "user_id": "user789",
  "username": "new_user",
  "email": "new.user@example.com"
}
```

#### Error Response (400)
- **error** (string) - Description of the error.

#### Error Response Example
```json
{
  "error": "Bad Request: Username or email already exists."
}
```
```

--------------------------------

### POST /api/v3/payments/init

Source: https://context7.com/rabbicik/paybylink/llms.txt

Initializes a new payment transaction. This endpoint is used to create a payment request with specified details like amount, currency, and merchant information.

```APIDOC
## POST /api/v3/payments/init

### Description
Initializes a new payment transaction. This endpoint is used to create a payment request with specified details like amount, currency, and merchant information.

### Method
POST

### Endpoint
/api/v3/payments/init

### Parameters
#### Query Parameters
- `amount` (decimal) - Required - Transaction amount
- `currency` (string) - Required - Currency code (e.g., USD, EUR)
- `merchantId` (string) - Required - Merchant identifier (UUID format)

### Request Example
```json
{
  "amount": 99.99,
  "currency": "USD",
  "merchantId": "550e8400-e29b-41d4-a716-446655440000"
}
```

### Response
#### Success Response (200)
- `transactionId` (string) - Unique transaction identifier
- `redirectUrl` (string) - URL to the payment gateway for completing the transaction
- `expiresAt` (datetime) - Transaction expiration time (ISO 8601 format)

#### Response Example
```json
{
  "transactionId": "txn_abc123def456",
  "redirectUrl": "https://payment.gateway.com/checkout/txn_abc123def456",
  "expiresAt": "2025-11-03T22:32:00Z"
}
```

### Authentication
- API Key (Header: X-API-Key)
- HMAC-SHA256 signature
```

--------------------------------

### POST /api/v3/payments/init

Source: https://github.com/rabbicik/paybylink/blob/main/Readme.md

Initializes a new payment transaction. This endpoint accepts payment details such as amount, currency, and merchant ID, and returns transaction information including a redirect URL.

```APIDOC
## POST /api/v3/payments/init

### Description
Initializes a new payment transaction. This endpoint accepts payment details such as amount, currency, and merchant ID, and returns transaction information including a redirect URL.

### Method
POST

### Endpoint
/api/v3/payments/init

### Parameters
#### Query Parameters
- **amount** (decimal) - Required - The payment amount.
- **currency** (string) - Optional - The ISO 4217 currency code.
- **merchantId** (string) - Required - The unique identifier for the merchant (UUID format).

### Request Example
```json
{
  "amount": 100.50,
  "currency": "USD",
  "merchantId": "a1b2c3d4-e5f6-7890-1234-567890abcdef"
}
```

### Response
#### Success Response (200)
- **transactionId** (string) - The unique identifier for the transaction.
- **redirectUrl** (string) - The URL to redirect the user to for payment.
- **expiresAt** (datetime) - The expiration time of the transaction in ISO 8601 format.

#### Response Example
```json
{
  "transactionId": "tx_abc123xyz789",
  "redirectUrl": "https://pay.example.com/pay?id=tx_abc123xyz789",
  "expiresAt": "2025-11-03T10:00:00Z"
}
```
```

--------------------------------

### Payment Initialization API

Source: https://github.com/rabbicik/paybylink/blob/main/Readme.md

Initiates a new payment transaction. Requires an API key, session token, and a digital signature for authorization.

```APIDOC
## POST /api/v3/payments/init

### Description
Initiates a new payment transaction.

### Method
POST

### Endpoint
/api/v3/payments/init

### Parameters
#### Query Parameters
- **apiKey** (string) - Required - Your unique API key for authentication.
- **sessionToken** (string) - Required - The token representing the current user session.

#### Request Body
- **digitalSignature** (string) - Required - The HMAC-SHA256 signature for the transaction request.

### Request Example
```json
{
  "digitalSignature": "your_hmac_sha256_signature_here"
}
```

### Response
#### Success Response (200)
- **transactionId** (string) - The unique identifier for the initiated transaction.
- **status** (string) - The current status of the transaction (e.g., PENDING, PROCESSING).

#### Response Example
```json
{
  "transactionId": "txn_123abc456def",
  "status": "PENDING"
}
```
```

--------------------------------

### Create Markdown Index for RAG System

Source: https://context7.com/rabbicik/paybylink/llms.txt

This Python function generates a structured markdown index from a PDF document, intended for use with Retrieval-Augmented Generation (RAG) systems like Context7. It processes PDF pages, identifies content sections (e.g., 'API Endpoints', 'Error codes'), and structures them into a markdown format. This organized output facilitates semantic search and efficient retrieval of information within the RAG system.

```python
import pdfplumber

def create_rag_index(pdf_path, output_path):
    """Create structured markdown index for RAG system"""

    with pdfplumber.open(pdf_path) as pdf:
        sections = []

        for page_num, page in enumerate(pdf.pages, start=1):
            text = page.extract_text()

            # Structure content by sections
            if "API Endpoints" in text:
                sections.append({
                    "page": page_num,
                    "type": "api_reference",
                    "content": text
                })
            elif "Error codes" in text:
                sections.append({
                    "page": page_num,
                    "type": "error_codes",
                    "content": text
                })

    # Generate markdown for RAG indexing
    markdown_output = []

    for section in sections:
        if section["type"] == "api_reference":
            markdown_output.append(f"""

```

--------------------------------

### API Schema

Source: https://context7.com/rabbicik/paybylink/llms.txt

JSON schema describing the API's structure and endpoints.

```APIDOC
## API Schema

### Description
This JSON schema defines the structure and available endpoints for the payment system API.

### Schema Details
- **api_version**: (string) The version of the API.
- **endpoints**: (array) A list of available API endpoints.
  - **method**: (string) The HTTP method for the endpoint (e.g., GET, POST).
  - **path**: (string) The URL path for the endpoint.
- **authentication**: (object) Details about the API's authentication mechanism.
  - **type**: (string) The type of authentication (e.g., HMAC-SHA256).
  - **headers**: (array) A list of required authentication headers.

### Example
```json
{
  "api_version": "3.x",
  "endpoints": [
    {"method": "GET", "path": "/api/v1/users"},
    {"method": "POST", "path": "/api/v1/users"}
  ],
  "authentication": {
    "type": "HMAC-SHA256",
    "headers": ["X-API-Key", "X-Signature"]
  }
}
```
```

--------------------------------

### Initialize Payment API Response

Source: https://context7.com/rabbicik/paybylink/llms.txt

This snippet shows a successful response after initializing a payment transaction via the PayByLink API. It provides the generated `transactionId`, the `redirectUrl` where the user will be directed to complete the payment, and the `expiresAt` timestamp indicating when the transaction will expire.

```json
{
  "transactionId": "txn_abc123def456",
  "redirectUrl": "https://payment.gateway.com/checkout/txn_abc123def456",
  "expiresAt": "2025-11-03T22:32:00Z"
}
```

--------------------------------

### Convert PDF Content to Markdown, JSON, and SQL (Python)

Source: https://context7.com/rabbicik/paybylink/llms.txt

This Python function, 'convert_to_formats', takes a PDF file path and an output directory as input. It uses the 'pdfplumber' library to extract text, parse API endpoints, and identify error codes from tables within the PDF. It then generates Markdown documentation, a JSON schema for API specifications, and SQL statements for an error code database. Dependencies include 'pdfplumber', 'json', 'csv', and 're'.

```python
import json
import csv
import pdfplumber
import re

def convert_to_formats(pdf_path, output_dir):
    """Convert PDF content to multiple structured formats"""

    with pdfplumber.open(pdf_path) as pdf:
        # Extract all content
        all_text = ""
        api_endpoints = []
        error_codes = []

        for page in pdf.pages:
            text = page.extract_text()
            all_text += text + "\n\n"

            # Parse API endpoints
            if "POST /api" in text or "GET /api" in text:
                endpoints = re.findall(r'(POST|GET)\s+(/api/v\d+/[^\s]+)', text)
                api_endpoints.extend(endpoints)

            # Parse error codes
            tables = page.extract_tables()
            for table in tables:
                if table and any("error" in str(cell).lower() for row in table for cell in row if cell):
                    error_codes.extend(table)

        # 1. Markdown output
        markdown_content = f"# Payment System API Documentation\n\n## Overview\n{all_text[:500]}\n\n## API Endpoints\n"
        for method, endpoint in api_endpoints:
            markdown_content += f"- **{method}** `{endpoint}`\n"

        with open(f"{output_dir}/api_documentation.md", 'w', encoding='utf-8') as f:
            f.write(markdown_content)

        # 2. JSON output for API specifications
        json_schema = {
            "api_version": "3.x",
            "endpoints": [
                {"method": method, "path": path}
                for method, path in api_endpoints
            ],
            "authentication": {
                "type": "HMAC-SHA256",
                "headers": ["X-API-Key", "X-Signature"]
            }
        }

        with open(f"{output_dir}/api_schema.json", 'w', encoding='utf-8') as f:
            json.dump(json_schema, f, indent=2)

        # 3. SQL for error codes database
        sql_output = """CREATE TABLE payment_errors (
    error_code VARCHAR(20) PRIMARY KEY,
    description TEXT,
    http_status INT,
    category VARCHAR(50)
);

INSERT INTO payment_errors VALUES
    ('INVALID_AMOUNT', 'Transaction amount is invalid or negative', 400, 'validation'),
    ('EXPIRED_TOKEN', 'Authentication token has expired', 401, 'authentication'),
    ('INSUFFICIENT_FUNDS', 'Merchant account has insufficient funds', 402, 'payment');
"""

        with open(f"{output_dir}/error_codes.sql", 'w', encoding='utf-8') as f:
            f.write(sql_output)

        return {
            "markdown": f"{output_dir}/api_documentation.md",
            "json": f"{output_dir}/api_schema.json",
            "sql": f"{output_dir}/error_codes.sql"
        }

# Convert to all formats
output_files = convert_to_formats("dokumentacja-przelewy.pdf", "./output")
print("Generated files:")
for format_type, filepath in output_files.items():
    print(f"  {format_type.upper()}: {filepath}")
```

--------------------------------

### PDF Content Parsing with pdfplumber (Python)

Source: https://context7.com/rabbicik/paybylink/llms.txt

Demonstrates how to use the pdfplumber Python library to programmatically extract text content and tabular data from PDF files. The library automatically handles decompression and font decoding, providing structured output.

```python
import pdfplumber

```

--------------------------------

### Initialize Payment API Request

Source: https://context7.com/rabbicik/paybylink/llms.txt

This snippet demonstrates how to initialize a payment transaction using the PayByLink API. It requires the transaction amount, currency code, and merchant ID. The response includes a unique transaction ID, a redirect URL to the payment gateway, and the transaction's expiration time. Authentication is handled via an API Key and HMAC-SHA256 signature.

```json
{
  "amount": 99.99,
  "currency": "USD",
  "merchantId": "550e8400-e29b-41d4-a716-446655440000"
}
```

--------------------------------

### PDF Structure Metadata

Source: https://context7.com/rabbicik/paybylink/llms.txt

Provides an overview of the PDF document's structural properties, including version, encoding, object and page counts, media box dimensions, and details on font families and their encodings. It also outlines the compression methods used.

```plaintext
PDF Version: 1.3
Encoding: Binary with FlateDecode compression
Object Count: 344
Page Count: 17 (pages 3-19 in object structure)
MediaBox: [0.0, 7.83, 595.5, 850.08]
Width: 595.5 pt (≈ 210 mm, A4 format)
Height: 842.25 pt (≈ 297 mm, A4 format)

Font Families:
- SourceSansPro-Regular (Type0/CIDFont) - Body text
- Arimo-Regular (Type0/CIDFont) - Supplementary text
- LeagueSpartan-Bold (Type0/CIDFont) - Bold headings
- Roboto-Bold (Type0/CIDFont) - Emphasis
- Gidole-Regular (Type0/CIDFont) - Technical text
- OpenSans-Regular (Type0/CIDFont) - Annotations
- Montserrat-Bold (Type3) - Main headings
- Montserrat-Regular (Type3) - Subheadings

Font Encoding:
  Encoding: /Identity-H (Unicode horizontal)
  CIDSystemInfo:
    Registry: Adobe
    Ordering: Identity
    Supplement: 0
  Subtype: /CIDFontType2 (TrueType)

Compression:
  Method: /FlateDecode (zlib/deflate)
  Average Compression Ratio: ~60-70%
  Example: 3800 bytes raw → 1800 bytes compressed
```

--------------------------------

### Python PDF Indexing and Extraction

Source: https://context7.com/rabbicik/paybylink/llms.txt

This Python code snippet utilizes the `pdfplumber` library to process a PDF document. It demonstrates functions for creating a Retrieval-Augmented Generation (RAG) index by extracting text and tables from specified sections and for analyzing PDF security features and metadata using `PyPDF2`. This is useful for programmatic access and analysis of PDF content.

```python
import pdfplumber
import PyPDF2

def create_rag_index(pdf_path, output_path):
    """Extract text and tables from PDF to create a RAG index."""
    sections = []
    markdown_output = []
    with pdfplumber.open(pdf_path) as pdf:
        # Example: Extracting content from specific pages or sections
        # This part would be more detailed based on actual PDF structure
        page_content = pdf.pages[0].extract_text() # Simplified example
        sections.append({"content": page_content})
        markdown_output.append(f"# Section 1\n{page_content}")

    # Write to markdown file
    with open(output_path, 'w', encoding='utf-8') as f:
        f.write('\n'.join(markdown_output))

    return len(sections)

# Create RAG index
# indexed_sections = create_rag_index("dokumentacja-przelewy.pdf", "payment_api_rag_index.md")
# print(f"Indexed {indexed_sections} sections for RAG system")

def analyze_pdf_security(pdf_path):
    """Analyze PDF security and metadata"""

    with open(pdf_path, 'rb') as file:
        reader = PyPDF2.PdfReader(file)

        # Check encryption status
        is_encrypted = reader.is_encrypted

        # Extract metadata
        metadata = reader.metadata

        # Get document info
        info = {
            "encryption": "YES" if is_encrypted else "NO",
            "page_count": len(reader.pages),
            "pdf_version": reader.pdf_header,
            "metadata": {
                "title": metadata.get('/Title', 'Not specified'),
                "author": metadata.get('/Author', 'Not specified'),
                "creator": metadata.get('/Creator', 'Not specified'),
                "producer": metadata.get('/Producer', 'Not specified'),
                "creation_date": metadata.get('/CreationDate', 'Not available')
            } if metadata else None
        }

        return info

# Analyze PDF security
# pdf_info = analyze_pdf_security("dokumentacja-przelewy.pdf")
# print(pdf_info)

# Page structure mapping for targeted content extraction
page_structure = {
    1: {"object": 3, "topic": "Title page, introduction"},
    2: {"object": 4, "topic": "System requirements, security"},
    3: {"object": 5, "topic": "API architecture, diagrams"},
    4: {"object": 6, "topic": "Payment initialization"},
    5: {"object": 7, "topic": "Response handling (callbacks)"},
    6: {"object": 8, "topic": "Token management"},
    7: {"object": 9, "topic": "Integration testing (sandbox)"},
    8: {"object": 10, "topic": "Code examples (REST)"},
    9: {"object": 11, "topic": "Error codes"},
    10: {"object": 12, "topic": "Transaction statuses"},
    11: {"object": 13, "topic": "Appendix A"},
    12: {"object": 14, "topic": "Appendix B"},
    13: {"object": 15, "topic": "Appendix C"},
    14: {"object": 16, "topic": "Changelog"},
    15: {"object": 17, "topic": "FAQ section"},
    16: {"object": 18, "topic": "Contact information"},
    17: {"object": 19, "topic": "Legal notices"}
}

def extract_specific_content(pdf_path, page_topics):
    """Extract content from specific pages based on topic"""
    results = {}

    with pdfplumber.open(pdf_path) as pdf:
        for page_num, info in page_topics.items():
            if page_num <= len(pdf.pages):
                page = pdf.pages[page_num - 1]
                results[info["topic"]] = {
                    "page": page_num,
                    "object": info["object"],
                    "text": page.extract_text(),
                    "tables": page.extract_tables()
                }

    return results

# Extract only API-related pages (4-8)
# api_pages = {k: v for k, v in page_structure.items() if 4 <= k <= 8}
# api_content = extract_specific_content("dokumentacja-przelewy.pdf", api_pages)

# Access specific content
# payment_init = api_content["Payment initialization"]
# print(f"Payment initialization content from page {payment_init['page']}:")
# print(payment_init['text'][:300])

```

--------------------------------

### PDF Graphical Resources Analysis

Source: https://context7.com/rabbicik/paybylink/llms.txt

Details the types of graphical resources embedded within the PDF, including color and monochrome images, patterns with linear gradients, and graphic states defining transparency levels. It also covers Form XObjects used for reusable graphical elements.

```plaintext
Color Images (DeviceRGB):
  Dimensions: 543×115 px, 678×144 px
  Compression: FlateDecode
  Transparency: SMask (soft mask)
  Usage: Logos, icons, diagrams

Monochrome Images (DeviceGray):
  Dimensions: Match RGB counterparts
  Purpose: Transparency masks

Patterns and Gradients:
  PatternType: 2 (Shading Pattern)
  ShadingType: 2 (Axial - linear gradient)
  ColorSpace: DeviceRGB
  Colors:
    C0: [0.894, 0.075, 0.227] (pink/magenta)
    C1: [0.984, 0.647, 0.867] (light pink)
  FunctionType: 2 (Linear interpolation)
  Usage: Header backgrounds, form field fills

Graphics States (ExtGState):
  G3: /BM /Normal /ca 1      (Opaque)
  G9: /BM /Normal /ca 0.0471 (Highly transparent, ~5%)
  G22: /BM /Normal /ca 0.0471 (Duplicate transparency)

Form XObjects:
  /Type /XObject
  /Subtype /Form
  /BBox [0 0 508 508]
  /Group << /S /Transparency /I true >>
  /Resources << /ExtGState << /G3 >> >>
  Usage: Reusable logos, watermarks, header/footer templates
```

--------------------------------

### PDF Content Parsing with pdfplumber

Source: https://github.com/rabbicik/paybylink/blob/main/Readme.md

This Python code snippet demonstrates how to open a PDF document and extract text and tables from each page using the pdfplumber library. It iterates through the pages of the PDF, allowing for further processing of the extracted content.

```python
import pdfplumber

with pdfplumber.open("dokumentacja-przelewy.pdf") as pdf:
    for page in pdf.pages:
        text = page.extract_text()
        tables = page.extract_tables()
        # Processing...
```

--------------------------------

### Extract and Process PDF Content with pdfplumber

Source: https://context7.com/rabbicik/paybylink/llms.txt

This Python code snippet uses the pdfplumber library to open a PDF file and iterate through its pages. For each page, it extracts plain text, tables, and image counts. The extracted text is printed (first 500 characters), and tables are processed row by row, with cells joined by '|'. This is useful for understanding the structure and content of a PDF document.

```python
import pdfplumber

with pdfplumber.open("dokumentacja-przelewy.pdf") as pdf:
    # Iterate through all 17 pages
    for page_num, page in enumerate(pdf.pages, start=1):
        # Extract plain text from page
        text = page.extract_text()

        # Extract tables (e.g., API parameters, error codes)
        tables = page.extract_tables()

        # Process text content
        if text:
            print(f"Page {page_num} Content:")
            print(text[:500])  # First 500 characters

        # Process tables
        for table_idx, table in enumerate(tables):
            print(f"\nPage {page_num}, Table {table_idx + 1}:")
            for row in table:
                print(" | ".join(str(cell) for cell in row if cell))

        # Extract images
        images = page.images
        print(f"Page {page_num} has {len(images)} images")
```

--------------------------------

### Transaction Confirmation API

Source: https://github.com/rabbicik/paybylink/blob/main/Readme.md

Confirms a payment transaction, typically after user approval or verification. Requires transaction ID and relevant confirmation details.

```APIDOC
## POST /api/v3/payments/{transactionId}/confirm

### Description
Confirms a payment transaction.

### Method
POST

### Endpoint
/api/v3/payments/{transactionId}/confirm

### Parameters
#### Path Parameters
- **transactionId** (string) - Required - The unique identifier of the transaction to confirm.

#### Query Parameters
- **apiKey** (string) - Required - Your unique API key for authentication.
- **sessionToken** (string) - Required - The token representing the current user session.

#### Request Body
- **confirmationData** (object) - Required - Data required for confirmation (e.g., OTP, 3D Secure details).

### Request Example
```json
{
  "confirmationData": {
    "otp": "123456"
  }
}
```

### Response
#### Success Response (200)
- **transactionId** (string) - The unique identifier of the confirmed transaction.
- **status** (string) - The final status of the transaction (e.g., COMPLETED, FAILED).

#### Response Example
```json
{
  "transactionId": "txn_123abc456def",
  "status": "COMPLETED"
}
```
```

--------------------------------

### Analyze PDF Security Information (Python)

Source: https://context7.com/rabbicik/paybylink/llms.txt

This Python code snippet analyzes a PDF document to extract security-related information such as encryption status, PDF version, page count, and metadata. It utilizes a hypothetical 'analyze_pdf_security' function and prints the extracted details. Dependencies include the function definition which is not provided here.

```python
security_info = analyze_pdf_security("dokumentacja-przelewy.pdf")

print(f"Encryption: {security_info['encryption']}")
print(f"PDF Version: {security_info['pdf_version']}")
print(f"Page Count: {security_info['page_count']}")
print(f"Metadata: {security_info['metadata']}")
```

--------------------------------

### POST /api/v3/payments/{transactionId}/confirm

Source: https://context7.com/rabbicik/paybylink/llms.txt

Confirms a payment transaction. This endpoint is typically called after the user has completed the payment process externally.

```APIDOC
## POST /api/v3/payments/{transactionId}/confirm

### Description
Confirms a payment transaction. This endpoint is typically called after the user has completed the payment process externally.

### Method
POST

### Endpoint
/api/v3/payments/{transactionId}/confirm

### Parameters
#### Path Parameters
- **transactionId** (string) - Required - The unique identifier for the transaction.

### Response
#### Success Response (200)
- **message** (string) - Confirmation message indicating the transaction has been confirmed.

#### Response Example
```json
{
  "message": "Transaction confirmed successfully."
}
```
```

--------------------------------

### Transaction Status API

Source: https://github.com/rabbicik/paybylink/blob/main/Readme.md

Retrieves the current status of a payment transaction using its unique transaction ID.

```APIDOC
## GET /api/v3/payments/{transactionId}/status

### Description
Retrieves the current status of a payment transaction.

### Method
GET

### Endpoint
/api/v3/payments/{transactionId}/status

### Parameters
#### Path Parameters
- **transactionId** (string) - Required - The unique identifier of the transaction to query.

#### Query Parameters
- **apiKey** (string) - Required - Your unique API key for authentication.
- **sessionToken** (string) - Required - The token representing the current user session.

### Response
#### Success Response (200)
- **transactionId** (string) - The unique identifier of the transaction.
- **status** (string) - The current status of the transaction (e.g., COMPLETED, FAILED, PENDING).
- **details** (object) - Optional - Additional details about the transaction status.

#### Response Example
```json
{
  "transactionId": "txn_123abc456def",
  "status": "COMPLETED",
  "details": {
    "paymentMethod": "Credit Card",
    "amount": 100.50,
    "currency": "USD"
  }
}
```
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.